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 #include <tbm_surface.h>
 489
 490
 491 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 492
 493
 494 #include <dali/devel-api/update/frame-callback-interface.h>
 495 #include <dali/devel-api/update/update-proxy.h>
 496
 497
 498 // add here SWIG version check
 499
 500 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 501 // disable Swig-dependent warnings
 502
 503 // 'identifier1' has C-linkage specified,
 504 // but returns UDT 'identifier2' which is incompatible with C
 505 #pragma warning(disable: 4190)
 506
 507 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 508 #pragma warning(disable: 4800)
 509
 510 // debug info too long etc etc
 511 #pragma warning(disable: 4786)
 512 #endif
 513
 514
 515 #include <stdexcept>
 516
 517
 518 #include <string>
 519
 520
 521 #include <vector>
 522 #include <algorithm>
 523 #include <stdexcept>
 524
 525
 526 #include <map>
 527 #include <algorithm>
 528 #include <stdexcept>
 529
 530
 531 #include <utility>
 532
 533
 534 typedef float floatp;
 535
 536 SWIGINTERN floatp *new_floatp(){
 537   return new float();
 538 }
 539 SWIGINTERN void delete_floatp(floatp *self){
 540   if (self) delete self;
 541 }
 542 SWIGINTERN void floatp_assign(floatp *self,float value){
 543   *self = value;
 544 }
 545 SWIGINTERN float floatp_value(floatp *self){
 546   return *self;
 547 }
 548 SWIGINTERN float *floatp_cast(floatp *self){
 549   return self;
 550 }
 551 SWIGINTERN floatp *floatp_frompointer(float *t){
 552   return (floatp *) t;
 553 }
 554
 555 typedef int intp;
 556
 557 SWIGINTERN intp *new_intp(){
 558   return new int();
 559 }
 560 SWIGINTERN void delete_intp(intp *self){
 561   if (self) delete self;
 562 }
 563 SWIGINTERN void intp_assign(intp *self,int value){
 564   *self = value;
 565 }
 566 SWIGINTERN int intp_value(intp *self){
 567   return *self;
 568 }
 569 SWIGINTERN int *intp_cast(intp *self){
 570   return self;
 571 }
 572 SWIGINTERN intp *intp_frompointer(int *t){
 573   return (intp *) t;
 574 }
 575
 576 typedef double doublep;
 577
 578 SWIGINTERN doublep *new_doublep(){
 579   return new double();
 580 }
 581 SWIGINTERN void delete_doublep(doublep *self){
 582   if (self) delete self;
 583 }
 584 SWIGINTERN void doublep_assign(doublep *self,double value){
 585   *self = value;
 586 }
 587 SWIGINTERN double doublep_value(doublep *self){
 588   return *self;
 589 }
 590 SWIGINTERN double *doublep_cast(doublep *self){
 591   return self;
 592 }
 593 SWIGINTERN doublep *doublep_frompointer(double *t){
 594   return (doublep *) t;
 595 }
 596
 597 typedef unsigned int uintp;
 598
 599 SWIGINTERN uintp *new_uintp(){
 600   return new unsigned int();
 601 }
 602 SWIGINTERN void delete_uintp(uintp *self){
 603   if (self) delete self;
 604 }
 605 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 606   *self = value;
 607 }
 608 SWIGINTERN unsigned int uintp_value(uintp *self){
 609   return *self;
 610 }
 611 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 612   return self;
 613 }
 614 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 615   return (uintp *) t;
 616 }
 617
 618 typedef unsigned short ushortp;
 619
 620 SWIGINTERN ushortp *new_ushortp(){
 621   return new unsigned short();
 622 }
 623 SWIGINTERN void delete_ushortp(ushortp *self){
 624   if (self) delete self;
 625 }
 626 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 627   *self = value;
 628 }
 629 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 630   return *self;
 631 }
 632 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 633   return self;
 634 }
 635 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 636   return (ushortp *) t;
 637 }
 638
 639 unsigned int int_to_uint(int x) {
 640    return (unsigned int) x;
 641 }
 642
 643
 644 using namespace Dali;
 645 using namespace Dali::Toolkit;
 646
 647 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 648 {
 649   bool result = false;
 650   try
 651   {
 652     // C++ code. DALi uses Handle <-> Body design pattern.
 653     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 654     // Handles in DALi can be converted into a boolean type
 655     // to check if the handle has a valid body attached to it.
 656     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 657     if( *self )
 658     {
 659       result = true;
 660     }
 661     else
 662     {
 663       result = false;
 664     }
 665   }
 666   catch (std::out_of_range& e)
 667   {
 668     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 669     return 0;
 670   }
 671   catch (std::exception& e)
 672   {
 673     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 674     return 0;
 675   }
 676   catch (DaliException e)
 677   {
 678     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 679     return 0;
 680   }
 681   catch (...)
 682   {
 683     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 684     return 0;
 685   }
 686   return result;
 687 }
 688
 689 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 690 {
 691   bool result = false;
 692   try
 693   {
 694     // C++ code. Check if two handles reference the same implemtion
 695     if( *self == rhs)
 696     {
 697       result = true;
 698     }
 699     else
 700     {
 701       result = false;
 702     }
 703   }
 704   catch (std::out_of_range& e)
 705   {
 706     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 707     return 0;
 708   }
 709   catch (std::exception& e)
 710   {
 711     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 712     return 0;
 713   }
 714   catch (DaliException e)
 715   {
 716     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 717     return 0;
 718   }
 719   catch (...)
 720   {
 721     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 722     return 0;
 723   }
 724   return result;
 725 }
 726
 727
 728 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 729      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 730    }
 731 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 732      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 733    }
 734 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 735         std::vector< Dali::TouchPoint >* pv = 0;
 736         if (capacity >= 0) {
 737           pv = new std::vector< Dali::TouchPoint >();
 738           pv->reserve(capacity);
 739        } else {
 740           throw std::out_of_range("capacity");
 741        }
 742        return pv;
 743       }
 744 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 745         if (index>=0 && index<(int)self->size())
 746           return (*self)[index];
 747         else
 748           throw std::out_of_range("index");
 749       }
 750 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 751         if (index>=0 && index<(int)self->size())
 752           return (*self)[index];
 753         else
 754           throw std::out_of_range("index");
 755       }
 756 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 757         if (index>=0 && index<(int)self->size())
 758           (*self)[index] = val;
 759         else
 760           throw std::out_of_range("index");
 761       }
 762 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 763         self->insert(self->end(), values.begin(), values.end());
 764       }
 765 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 766         if (index < 0)
 767           throw std::out_of_range("index");
 768         if (count < 0)
 769           throw std::out_of_range("count");
 770         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 771           throw std::invalid_argument("invalid range");
 772         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 773       }
 774 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 775         if (index>=0 && index<(int)self->size()+1)
 776           self->insert(self->begin()+index, x);
 777         else
 778           throw std::out_of_range("index");
 779       }
 780 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 781         if (index>=0 && index<(int)self->size()+1)
 782           self->insert(self->begin()+index, values.begin(), values.end());
 783         else
 784           throw std::out_of_range("index");
 785       }
 786 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 787         if (index>=0 && index<(int)self->size())
 788           self->erase(self->begin() + index);
 789         else
 790           throw std::out_of_range("index");
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 793         if (index < 0)
 794           throw std::out_of_range("index");
 795         if (count < 0)
 796           throw std::out_of_range("count");
 797         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 798           throw std::invalid_argument("invalid range");
 799         self->erase(self->begin()+index, self->begin()+index+count);
 800       }
 801 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 802         if (count < 0)
 803           throw std::out_of_range("count");
 804         return new std::vector< Dali::TouchPoint >(count, value);
 805       }
 806 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 807         std::reverse(self->begin(), self->end());
 808       }
 809 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 810         if (index < 0)
 811           throw std::out_of_range("index");
 812         if (count < 0)
 813           throw std::out_of_range("count");
 814         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 815           throw std::invalid_argument("invalid range");
 816         std::reverse(self->begin()+index, self->begin()+index+count);
 817       }
 818 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 819         if (index < 0)
 820           throw std::out_of_range("index");
 821         if (index+values.size() > self->size())
 822           throw std::out_of_range("index");
 823         std::copy(values.begin(), values.end(), self->begin()+index);
 824       }
 825 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 826          return self->Empty();
 827       }
 828 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 829         return self->GetConnectionCount();
 830       }
 831 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 832           self->Connect( func );
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 835           self->Disconnect( func );
 836       }
 837 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 838           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 839 /*@SWIG@*/ self->Emit( arg );
 840       }
 841 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 842          return self->Empty();
 843       }
 844 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 845         return self->GetConnectionCount();
 846       }
 847 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 848           self->Connect( func );
 849       }
 850 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 851           self->Disconnect( func );
 852       }
 853 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 854           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 855 /*@SWIG@*/ self->Emit( arg );
 856       }
 857 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 858          return self->Empty();
 859       }
 860 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 861         return self->GetConnectionCount();
 862       }
 863 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 864           self->Connect( func );
 865       }
 866 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 867           self->Disconnect( func );
 868       }
 869 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 870           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 871 /*@SWIG@*/ self->Emit( arg );
 872       }
 873 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 874          return self->Empty();
 875       }
 876 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 877         return self->GetConnectionCount();
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 880           self->Connect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 883           self->Disconnect( func );
 884       }
 885 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 886           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 887 /*@SWIG@*/ self->Emit( arg );
 888       }
 889 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 890          return self->Empty();
 891       }
 892 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 893         return self->GetConnectionCount();
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 896         self->Connect( func );
 897       }
 898 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 899         self->Disconnect( func );
 900       }
 901 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 902         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 903 /*@SWIG@*/ self->Emit( arg1, arg2 );
 904       }
 905 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 906          return self->Empty();
 907       }
 908 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 909         return self->GetConnectionCount();
 910       }
 911 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 912         self->Connect( func );
 913       }
 914 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 915         self->Disconnect( func );
 916       }
 917 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,Dali::Actor arg1,Dali::TouchEvent const &arg2){
 918         return self->Emit( arg1, arg2 );
 919       }
 920 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 921          return self->Empty();
 922       }
 923 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 924         return self->GetConnectionCount();
 925       }
 926 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 927         self->Connect( func );
 928       }
 929 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 930         self->Disconnect( func );
 931       }
 932 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 933         return self->Emit( arg1, arg2 );
 934       }
 935 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 936          return self->Empty();
 937       }
 938 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 939         return self->GetConnectionCount();
 940       }
 941 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 942         self->Connect( func );
 943       }
 944 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 945         self->Disconnect( func );
 946       }
 947 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 948         return self->Emit( arg1, arg2 );
 949       }
 950 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 951          return self->Empty();
 952       }
 953 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 954         return self->GetConnectionCount();
 955       }
 956 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 957           self->Connect( func );
 958       }
 959 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 960           self->Disconnect( func );
 961       }
 962 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 963           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 964 /*@SWIG@*/ self->Emit( arg );
 965       }
 966 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 967          return self->Empty();
 968       }
 969 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 970         return self->GetConnectionCount();
 971       }
 972 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 973           self->Connect( func );
 974       }
 975 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 976           self->Disconnect( func );
 977       }
 978 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 979           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 980 /*@SWIG@*/ self->Emit( arg );
 981       }
 982 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 983          return self->Empty();
 984       }
 985 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 986         return self->GetConnectionCount();
 987       }
 988 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 989           self->Connect( func );
 990       }
 991 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 992           self->Disconnect( func );
 993       }
 994 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchEvent const &) > *self,Dali::TouchEvent const &arg){
 995           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 996 /*@SWIG@*/ self->Emit( arg );
 997       }
 998 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 999          return self->Empty();
1000       }
1001 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
1002         return self->GetConnectionCount();
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1005           self->Connect( func );
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1008           self->Disconnect( func );
1009       }
1010 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1011           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1012 /*@SWIG@*/ self->Emit( arg );
1013       }
1014 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1015          return self->Empty();
1016       }
1017 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1018         return self->GetConnectionCount();
1019       }
1020 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1021         self->Connect( func );
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1024         self->Disconnect( func );
1025       }
1026 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1027         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1028 /*@SWIG@*/ self->Emit( arg1, arg2 );
1029       }
1030 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1031          return self->Empty();
1032       }
1033 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1034         return self->GetConnectionCount();
1035       }
1036 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1037         self->Connect( func );
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1040         self->Disconnect( func );
1041       }
1042 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1043         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1044 /*@SWIG@*/ self->Emit( arg1, arg2 );
1045       }
1046 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1047          return self->Empty();
1048       }
1049 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1050         return self->GetConnectionCount();
1051       }
1052 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1053         self->Connect( func );
1054       }
1055 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1056         self->Disconnect( func );
1057       }
1058 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1059         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1060 /*@SWIG@*/ self->Emit( arg1, arg2 );
1061       }
1062 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1063          return self->Empty();
1064       }
1065 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1066         return self->GetConnectionCount();
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1069           return self->Connect( func );
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1072           self->Disconnect( func );
1073       }
1074 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1075           self->Emit( arg1, arg3 );
1076       }
1077 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1078          return self->Empty();
1079       }
1080 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1081         return self->GetConnectionCount();
1082       }
1083 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1084           return self->Connect( func );
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1087           self->Disconnect( func );
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1090           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1091 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1092       }
1093
1094 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1095          return self->Empty();
1096       }
1097 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1098         return self->GetConnectionCount();
1099       }
1100 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1101           self->Connect( func );
1102       }
1103 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1104           self->Disconnect( func );
1105       }
1106 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1107           return self->Emit();
1108       }
1109
1110 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1111         std::vector< unsigned int >* pv = 0;
1112         if (capacity >= 0) {
1113           pv = new std::vector< unsigned int >();
1114           pv->reserve(capacity);
1115        } else {
1116           throw std::out_of_range("capacity");
1117        }
1118        return pv;
1119       }
1120 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1121         if (index>=0 && index<(int)self->size())
1122           return (*self)[index];
1123         else
1124           throw std::out_of_range("index");
1125       }
1126 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1127         if (index>=0 && index<(int)self->size())
1128           return (*self)[index];
1129         else
1130           throw std::out_of_range("index");
1131       }
1132 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1133         if (index>=0 && index<(int)self->size())
1134           (*self)[index] = val;
1135         else
1136           throw std::out_of_range("index");
1137       }
1138 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1139         self->insert(self->end(), values.begin(), values.end());
1140       }
1141 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1142         if (index < 0)
1143           throw std::out_of_range("index");
1144         if (count < 0)
1145           throw std::out_of_range("count");
1146         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1147           throw std::invalid_argument("invalid range");
1148         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1149       }
1150 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1151         if (index>=0 && index<(int)self->size()+1)
1152           self->insert(self->begin()+index, x);
1153         else
1154           throw std::out_of_range("index");
1155       }
1156 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1157         if (index>=0 && index<(int)self->size()+1)
1158           self->insert(self->begin()+index, values.begin(), values.end());
1159         else
1160           throw std::out_of_range("index");
1161       }
1162 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1163         if (index>=0 && index<(int)self->size())
1164           self->erase(self->begin() + index);
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1169         if (index < 0)
1170           throw std::out_of_range("index");
1171         if (count < 0)
1172           throw std::out_of_range("count");
1173         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1174           throw std::invalid_argument("invalid range");
1175         self->erase(self->begin()+index, self->begin()+index+count);
1176       }
1177 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1178         if (count < 0)
1179           throw std::out_of_range("count");
1180         return new std::vector< unsigned int >(count, value);
1181       }
1182 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1183         std::reverse(self->begin(), self->end());
1184       }
1185 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1186         if (index < 0)
1187           throw std::out_of_range("index");
1188         if (count < 0)
1189           throw std::out_of_range("count");
1190         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1191           throw std::invalid_argument("invalid range");
1192         std::reverse(self->begin()+index, self->begin()+index+count);
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1195         if (index < 0)
1196           throw std::out_of_range("index");
1197         if (index+values.size() > self->size())
1198           throw std::out_of_range("index");
1199         std::copy(values.begin(), values.end(), self->begin()+index);
1200       }
1201 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1202         return std::find(self->begin(), self->end(), value) != self->end();
1203       }
1204 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1205         int index = -1;
1206         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1207         if (it != self->end())
1208           index = (int)(it - self->begin());
1209         return index;
1210       }
1211 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1212         int index = -1;
1213         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1214         if (rit != self->rend())
1215           index = (int)(self->rend() - 1 - rit);
1216         return index;
1217       }
1218 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1219         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1220         if (it != self->end()) {
1221           self->erase(it);
1222           return true;
1223         }
1224         return false;
1225       }
1226 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1227         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1228         if (capacity >= 0) {
1229           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1230           pv->reserve(capacity);
1231        } else {
1232           throw std::out_of_range("capacity");
1233        }
1234        return pv;
1235       }
1236 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1237         if (index>=0 && index<(int)self->size())
1238           return (*self)[index];
1239         else
1240           throw std::out_of_range("index");
1241       }
1242 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1243         if (index>=0 && index<(int)self->size())
1244           return (*self)[index];
1245         else
1246           throw std::out_of_range("index");
1247       }
1248 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1249         if (index>=0 && index<(int)self->size())
1250           (*self)[index] = val;
1251         else
1252           throw std::out_of_range("index");
1253       }
1254 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1255         self->insert(self->end(), values.begin(), values.end());
1256       }
1257 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1258         if (index < 0)
1259           throw std::out_of_range("index");
1260         if (count < 0)
1261           throw std::out_of_range("count");
1262         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1263           throw std::invalid_argument("invalid range");
1264         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1265       }
1266 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1267         if (index>=0 && index<(int)self->size()+1)
1268           self->insert(self->begin()+index, x);
1269         else
1270           throw std::out_of_range("index");
1271       }
1272 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1273         if (index>=0 && index<(int)self->size()+1)
1274           self->insert(self->begin()+index, values.begin(), values.end());
1275         else
1276           throw std::out_of_range("index");
1277       }
1278 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1279         if (index>=0 && index<(int)self->size())
1280           self->erase(self->begin() + index);
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1285         if (index < 0)
1286           throw std::out_of_range("index");
1287         if (count < 0)
1288           throw std::out_of_range("count");
1289         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1290           throw std::invalid_argument("invalid range");
1291         self->erase(self->begin()+index, self->begin()+index+count);
1292       }
1293 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1294         if (count < 0)
1295           throw std::out_of_range("count");
1296         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1297       }
1298 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1299         std::reverse(self->begin(), self->end());
1300       }
1301 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1302         if (index < 0)
1303           throw std::out_of_range("index");
1304         if (count < 0)
1305           throw std::out_of_range("count");
1306         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1307           throw std::invalid_argument("invalid range");
1308         std::reverse(self->begin()+index, self->begin()+index+count);
1309       }
1310 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1311         if (index < 0)
1312           throw std::out_of_range("index");
1313         if (index+values.size() > self->size())
1314           throw std::out_of_range("index");
1315         std::copy(values.begin(), values.end(), self->begin()+index);
1316       }
1317 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1318         std::vector< Dali::Actor >* pv = 0;
1319         if (capacity >= 0) {
1320           pv = new std::vector< Dali::Actor >();
1321           pv->reserve(capacity);
1322        } else {
1323           throw std::out_of_range("capacity");
1324        }
1325        return pv;
1326       }
1327 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1328         if (index>=0 && index<(int)self->size())
1329           return (*self)[index];
1330         else
1331           throw std::out_of_range("index");
1332       }
1333 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1334         if (index>=0 && index<(int)self->size())
1335           return (*self)[index];
1336         else
1337           throw std::out_of_range("index");
1338       }
1339 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1340         if (index>=0 && index<(int)self->size())
1341           (*self)[index] = val;
1342         else
1343           throw std::out_of_range("index");
1344       }
1345 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1346         self->insert(self->end(), values.begin(), values.end());
1347       }
1348 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1349         if (index < 0)
1350           throw std::out_of_range("index");
1351         if (count < 0)
1352           throw std::out_of_range("count");
1353         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1354           throw std::invalid_argument("invalid range");
1355         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1356       }
1357 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1358         if (index>=0 && index<(int)self->size()+1)
1359           self->insert(self->begin()+index, x);
1360         else
1361           throw std::out_of_range("index");
1362       }
1363 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1364         if (index>=0 && index<(int)self->size()+1)
1365           self->insert(self->begin()+index, values.begin(), values.end());
1366         else
1367           throw std::out_of_range("index");
1368       }
1369 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1370         if (index>=0 && index<(int)self->size())
1371           self->erase(self->begin() + index);
1372         else
1373           throw std::out_of_range("index");
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1376         if (index < 0)
1377           throw std::out_of_range("index");
1378         if (count < 0)
1379           throw std::out_of_range("count");
1380         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1381           throw std::invalid_argument("invalid range");
1382         self->erase(self->begin()+index, self->begin()+index+count);
1383       }
1384 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1385         if (count < 0)
1386           throw std::out_of_range("count");
1387         return new std::vector< Dali::Actor >(count, value);
1388       }
1389 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1390         std::reverse(self->begin(), self->end());
1391       }
1392 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1393         if (index < 0)
1394           throw std::out_of_range("index");
1395         if (count < 0)
1396           throw std::out_of_range("count");
1397         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1398           throw std::invalid_argument("invalid range");
1399         std::reverse(self->begin()+index, self->begin()+index+count);
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1402         if (index < 0)
1403           throw std::out_of_range("index");
1404         if (index+values.size() > self->size())
1405           throw std::out_of_range("index");
1406         std::copy(values.begin(), values.end(), self->begin()+index);
1407       }
1408 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1409          return self->Empty();
1410       }
1411 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1412         return self->GetConnectionCount();
1413       }
1414 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1415           self->Connect( func );
1416       }
1417 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1418           self->Disconnect( func );
1419       }
1420 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1421           return self->Emit( arg );
1422       }
1423 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1424          return self->Empty();
1425       }
1426 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1427         return self->GetConnectionCount();
1428       }
1429 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1430         self->Connect( func );
1431       }
1432 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1433         self->Disconnect( func );
1434       }
1435 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1436         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1437 /*@SWIG@*/ self->Emit( arg1, arg2 );
1438       }
1439 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1440          return self->Empty();
1441       }
1442 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1443         return self->GetConnectionCount();
1444       }
1445 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1446         self->Connect( func );
1447       }
1448 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1449         self->Disconnect( func );
1450       }
1451 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1452         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1453 /*@SWIG@*/ self->Emit( arg1, arg2 );
1454       }
1455 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1456          return self->Empty();
1457       }
1458 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1459         return self->GetConnectionCount();
1460       }
1461 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1462         self->Connect( func );
1463       }
1464 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1465         self->Disconnect( func );
1466       }
1467 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1468         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1469 /*@SWIG@*/ self->Emit( arg1, arg2 );
1470       }
1471 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1472          return self->Empty();
1473       }
1474 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1475         return self->GetConnectionCount();
1476       }
1477 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1478         self->Connect( func );
1479       }
1480 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1481         self->Disconnect( func );
1482       }
1483 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1484         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1485 /*@SWIG@*/ self->Emit( arg1, arg2 );
1486       }
1487 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1488          return self->Empty();
1489       }
1490 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1491         return self->GetConnectionCount();
1492       }
1493 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1494           self->Connect( func );
1495       }
1496 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1497           self->Disconnect( func );
1498       }
1499 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1500           return self->Emit( arg );
1501       }
1502 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1503          return self->Empty();
1504       }
1505 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1506         return self->GetConnectionCount();
1507       }
1508 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1509           self->Connect( func );
1510       }
1511 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1512           self->Disconnect( func );
1513       }
1514 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1515           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1516 /*@SWIG@*/ self->Emit( arg );
1517       }
1518 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1519          return self->Empty();
1520       }
1521 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1522         return self->GetConnectionCount();
1523       }
1524 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1525           return self->Connect( func );
1526       }
1527 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1528           self->Disconnect( func );
1529       }
1530 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1531           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1532 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1533       }
1534 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1535          return self->Empty();
1536       }
1537 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1538         return self->GetConnectionCount();
1539       }
1540 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1541           self->Connect( func );
1542       }
1543 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1544           self->Disconnect( func );
1545       }
1546 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1547           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1548 /*@SWIG@*/ self->Emit( arg );
1549       }
1550 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1551          return self->Empty();
1552       }
1553 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1554         return self->GetConnectionCount();
1555       }
1556 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1557           return self->Connect( func );
1558       }
1559 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1560           self->Disconnect( func );
1561       }
1562 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1563           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1564 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1565       }
1566 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1567          return self->Empty();
1568       }
1569 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1570         return self->GetConnectionCount();
1571       }
1572 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1573           self->Connect( func );
1574       }
1575 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1576           self->Disconnect( func );
1577       }
1578 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1579           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1580 /*@SWIG@*/ self->Emit( arg );
1581       }
1582 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1583          return self->Empty();
1584       }
1585 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1586         return self->GetConnectionCount();
1587       }
1588 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1589           self->Connect( func );
1590       }
1591 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1592           self->Disconnect( func );
1593       }
1594 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1595           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1596 /*@SWIG@*/ self->Emit( arg );
1597       }
1598
1599
1600 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1601          return self->Empty();
1602       }
1603 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1604         return self->GetConnectionCount();
1605       }
1606 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1607         self->Connect( func );
1608       }
1609 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1610         self->Disconnect( func );
1611       }
1612 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1613         return self->Emit( arg1, arg2 );
1614       }
1615 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1616          return self->Empty();
1617       }
1618 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1619         return self->GetConnectionCount();
1620       }
1621 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1622           self->Connect( func );
1623       }
1624 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1625           self->Disconnect( func );
1626       }
1627 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1628           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1629 /*@SWIG@*/ self->Emit( arg );
1630       }
1631 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1632          return self->Empty();
1633       }
1634 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1635         return self->GetConnectionCount();
1636       }
1637 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1638           self->Connect( func );
1639       }
1640 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1641           self->Disconnect( func );
1642       }
1643 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1644           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1645 /*@SWIG@*/ self->Emit( arg );
1646       }
1647 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1648          return self->Empty();
1649       }
1650 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1651         return self->GetConnectionCount();
1652       }
1653 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1654         self->Connect( func );
1655       }
1656 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1657         self->Disconnect( func );
1658       }
1659 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1660         return self->Emit( arg1, arg2 );
1661       }
1662 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1663          return self->Empty();
1664       }
1665 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1666         return self->GetConnectionCount();
1667       }
1668 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1669         self->Connect( func );
1670       }
1671 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1672         self->Disconnect( func );
1673       }
1674 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1675         return self->Emit( arg1, arg2 );
1676       }
1677
1678 /* ---------------------------------------------------
1679  * C++ director class methods
1680  * --------------------------------------------------- */
1681
1682 #include "dali_wrap.h"
1683
1684 /*
1685  *  Widget director
1686  */
1687 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1688   swig_init_callbacks();
1689 }
1690
1691 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1692 }
1693
1694 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1695   char * jcontentInfo = 0 ;
1696   void * jwindow  ;
1697
1698   if (!swig_callbackOnCreate) {
1699     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1700     return;
1701   } else {
1702     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1703     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1704     swig_callbackOnCreate(jcontentInfo, jwindow);
1705   }
1706 }
1707
1708 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1709   char * jcontentInfo = 0 ;
1710   int jtype  ;
1711
1712   if (!swig_callbackOnTerminate) {
1713     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1714     return;
1715   } else {
1716     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1717     jtype = (int)type;
1718     swig_callbackOnTerminate(jcontentInfo, jtype);
1719   }
1720 }
1721
1722 void SwigDirector_WidgetImpl::OnPause() {
1723   if (!swig_callbackOnPause) {
1724     Dali::Internal::Adaptor::Widget::OnPause();
1725     return;
1726   } else {
1727     swig_callbackOnPause();
1728   }
1729 }
1730
1731 void SwigDirector_WidgetImpl::OnResume() {
1732   if (!swig_callbackOnResume) {
1733     Dali::Internal::Adaptor::Widget::OnResume();
1734     return;
1735   } else {
1736     swig_callbackOnResume();
1737   }
1738 }
1739
1740 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1741   void * jwindow  ;
1742
1743   if (!swig_callbackOnResize) {
1744     Dali::Internal::Adaptor::Widget::OnResize(window);
1745     return;
1746   } else {
1747     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1748     swig_callbackOnResize(jwindow);
1749   }
1750 }
1751
1752 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1753   char * jcontentInfo = 0 ;
1754   int jforce  ;
1755
1756   if (!swig_callbackOnUpdate) {
1757     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1758     return;
1759   } else {
1760     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1761     jforce = force;
1762     swig_callbackOnUpdate(jcontentInfo, jforce);
1763   }
1764 }
1765
1766 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1767   void * jslotObserver = 0 ;
1768   void * jcallback = 0 ;
1769
1770   if (!swig_callbackSignalConnected) {
1771     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1772     return;
1773   } else {
1774     jslotObserver = (void *) slotObserver;
1775     jcallback = (void *) callback;
1776     swig_callbackSignalConnected(jslotObserver, jcallback);
1777   }
1778 }
1779
1780 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1781   void * jslotObserver = 0 ;
1782   void * jcallback = 0 ;
1783
1784   if (!swig_callbackSignalDisconnected) {
1785     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1786     return;
1787   } else {
1788     jslotObserver = (void *) slotObserver;
1789     jcallback = (void *) callback;
1790     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1791   }
1792 }
1793
1794 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1795
1796   swig_callbackOnCreate = callbackOnCreate;
1797   swig_callbackOnTerminate = callbackOnTerminate;
1798   swig_callbackOnPause = callbackOnPause;
1799   swig_callbackOnResume = callbackOnResume;
1800   swig_callbackOnResize = callbackOnResize;
1801   swig_callbackOnUpdate = callbackOnUpdate;
1802   swig_callbackSignalConnected = callbackSignalConnected;
1803   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1804 }
1805
1806 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1807   swig_callbackOnCreate = 0;
1808   swig_callbackOnTerminate = 0;
1809   swig_callbackOnPause = 0;
1810   swig_callbackOnResume = 0;
1811   swig_callbackOnResize = 0;
1812   swig_callbackOnUpdate = 0;
1813   swig_callbackSignalConnected = 0;
1814   swig_callbackSignalDisconnected = 0;
1815 }
1816
1817
1818 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1819   swig_init_callbacks();
1820 }
1821
1822 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1823
1824 }
1825
1826
1827 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1828   int jdepth  ;
1829
1830   if (!swig_callbackOnSceneConnection) {
1831     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1832     return;
1833   } else {
1834     jdepth = depth;
1835     swig_callbackOnSceneConnection(jdepth);
1836   }
1837 }
1838
1839 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1840   if (!swig_callbackOnSceneDisconnection) {
1841     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1842     return;
1843   } else {
1844     swig_callbackOnSceneDisconnection();
1845   }
1846 }
1847
1848 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1849   void * jchild = 0 ;
1850
1851   if (!swig_callbackOnChildAdd) {
1852     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1853     return;
1854   } else {
1855     jchild = (Dali::Actor *) &child;
1856     swig_callbackOnChildAdd(jchild);
1857   }
1858 }
1859
1860 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1861   void * jchild = 0 ;
1862
1863   if (!swig_callbackOnChildRemove) {
1864     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1865     return;
1866   } else {
1867     jchild = (Dali::Actor *) &child;
1868     swig_callbackOnChildRemove(jchild);
1869   }
1870 }
1871
1872 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1873   int jindex  ;
1874   void * jpropertyValue  ;
1875
1876   if (!swig_callbackOnPropertySet) {
1877     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1878     return;
1879   } else {
1880     jindex = index;
1881     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1882     swig_callbackOnPropertySet(jindex, jpropertyValue);
1883   }
1884 }
1885
1886 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1887   void * jtargetSize = 0 ;
1888
1889   if (!swig_callbackOnSizeSet) {
1890     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1891     return;
1892   } else {
1893     jtargetSize = (Dali::Vector3 *) &targetSize;
1894     swig_callbackOnSizeSet(jtargetSize);
1895   }
1896 }
1897
1898 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1899   void * janimation = 0 ;
1900   void * jtargetSize = 0 ;
1901
1902   if (!swig_callbackOnSizeAnimation) {
1903     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1904     return;
1905   } else {
1906     janimation = (Dali::Animation *) &animation;
1907     jtargetSize = (Dali::Vector3 *) &targetSize;
1908     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1909   }
1910 }
1911
1912 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1913   bool c_result = SwigValueInit< bool >() ;
1914   unsigned int jresult = 0 ;
1915   void * jarg0 = 0 ;
1916
1917   if (!swig_callbackOnHoverEvent) {
1918     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1919   } else {
1920     jarg0 = (Dali::HoverEvent *) &event;
1921     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1922     c_result = jresult ? true : false;
1923   }
1924   return c_result;
1925 }
1926
1927 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1928   bool c_result = SwigValueInit< bool >() ;
1929   unsigned int jresult = 0 ;
1930   void * jarg0 = 0 ;
1931
1932   if (!swig_callbackOnKeyEvent) {
1933     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1934   } else {
1935     jarg0 = (Dali::KeyEvent *) &event;
1936     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1937     c_result = jresult ? true : false;
1938   }
1939   return c_result;
1940 }
1941
1942 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1943   bool c_result = SwigValueInit< bool >() ;
1944   unsigned int jresult = 0 ;
1945   void * jarg0 = 0 ;
1946
1947   if (!swig_callbackOnWheelEvent) {
1948     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1949   } else {
1950     jarg0 = (Dali::WheelEvent *) &event;
1951     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1952     c_result = jresult ? true : false;
1953   }
1954   return c_result;
1955 }
1956
1957 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1958   void * jsize = 0 ;
1959   void * jcontainer = 0 ;
1960
1961   if (!swig_callbackOnRelayout) {
1962     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1963     return;
1964   } else {
1965     jsize = (Dali::Vector2 *) &size;
1966     jcontainer = (Dali::RelayoutContainer *) &container;
1967     swig_callbackOnRelayout(jsize, jcontainer);
1968   }
1969 }
1970
1971 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1972   int jpolicy  ;
1973   int jdimension  ;
1974
1975   if (!swig_callbackOnSetResizePolicy) {
1976     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1977     return;
1978   } else {
1979     jpolicy = (int)policy;
1980     jdimension = (int)dimension;
1981     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1982   }
1983 }
1984
1985 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1986   Dali::Vector3 c_result ;
1987   void * jresult = 0 ;
1988
1989   if (!swig_callbackGetNaturalSize) {
1990     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1991   } else {
1992     jresult = (void *) swig_callbackGetNaturalSize();
1993     if (!jresult) {
1994       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1995       return c_result;
1996     }
1997     c_result = *(Dali::Vector3 *)jresult;
1998   }
1999   return c_result;
2000 }
2001
2002 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2003   float c_result = SwigValueInit< float >() ;
2004   float jresult = 0 ;
2005   void * jchild = 0 ;
2006   int jdimension  ;
2007
2008   if (!swig_callbackCalculateChildSize) {
2009     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2010   } else {
2011     jchild = (Dali::Actor *) &child;
2012     jdimension = (int)dimension;
2013     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2014     c_result = (float)jresult;
2015   }
2016   return c_result;
2017 }
2018
2019 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2020   float c_result = SwigValueInit< float >() ;
2021   float jresult = 0 ;
2022   float jwidth  ;
2023
2024   if (!swig_callbackGetHeightForWidth) {
2025     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2026   } else {
2027     jwidth = width;
2028     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2029     c_result = (float)jresult;
2030   }
2031   return c_result;
2032 }
2033
2034 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2035   float c_result = SwigValueInit< float >() ;
2036   float jresult = 0 ;
2037   float jheight  ;
2038
2039   if (!swig_callbackGetWidthForHeight) {
2040     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2041   } else {
2042     jheight = height;
2043     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2044     c_result = (float)jresult;
2045   }
2046   return c_result;
2047 }
2048
2049 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2050   bool c_result = SwigValueInit< bool >() ;
2051   unsigned int jresult = 0 ;
2052   int jdimension  ;
2053
2054   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2055     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2056   } else {
2057     jdimension = (int)dimension;
2058     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2059     c_result = jresult ? true : false;
2060   }
2061   return c_result;
2062 }
2063
2064 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2065   int jdimension  ;
2066
2067   if (!swig_callbackOnCalculateRelayoutSize) {
2068     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2069     return;
2070   } else {
2071     jdimension = (int)dimension;
2072     swig_callbackOnCalculateRelayoutSize(jdimension);
2073   }
2074 }
2075
2076 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2077   float jsize  ;
2078   int jdimension  ;
2079
2080   if (!swig_callbackOnLayoutNegotiated) {
2081     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2082     return;
2083   } else {
2084     jsize = size;
2085     jdimension = (int)dimension;
2086     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2087   }
2088 }
2089
2090 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2091   return Dali::CustomActorImpl::GetExtension();
2092 }
2093
2094 void SwigDirector_ViewImpl::OnInitialize() {
2095   if (!swig_callbackOnInitialize) {
2096     Dali::Toolkit::Internal::Control::OnInitialize();
2097     return;
2098   } else {
2099     swig_callbackOnInitialize();
2100   }
2101 }
2102
2103 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2104   void * jstyleManager  ;
2105   int jchange  ;
2106
2107   if (!swig_callbackOnStyleChange) {
2108     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2109     return;
2110   } else {
2111     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2112     jchange = (int)change;
2113     swig_callbackOnStyleChange(jstyleManager, jchange);
2114   }
2115 }
2116
2117 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2118   bool c_result = SwigValueInit< bool >() ;
2119   unsigned int jresult = 0 ;
2120
2121   if (!swig_callbackOnAccessibilityActivated) {
2122     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2123   } else {
2124     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2125     c_result = jresult ? true : false;
2126   }
2127   return c_result;
2128 }
2129
2130 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2131   bool c_result = SwigValueInit< bool >() ;
2132   unsigned int jresult = 0 ;
2133   void * jgesture  ;
2134
2135   if (!swig_callbackOnAccessibilityPan) {
2136     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2137   } else {
2138     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2139     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2140     c_result = jresult ? true : false;
2141   }
2142   return c_result;
2143 }
2144
2145 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2146   bool c_result = SwigValueInit< bool >() ;
2147   unsigned int jresult = 0 ;
2148   unsigned int jisIncrease  ;
2149
2150   if (!swig_callbackOnAccessibilityValueChange) {
2151     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2152   } else {
2153     jisIncrease = isIncrease;
2154     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2155     c_result = jresult ? true : false;
2156   }
2157   return c_result;
2158 }
2159
2160 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2161   bool c_result = SwigValueInit< bool >() ;
2162   unsigned int jresult = 0 ;
2163
2164   if (!swig_callbackOnAccessibilityZoom) {
2165     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2166   } else {
2167     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2168     c_result = jresult ? true : false;
2169   }
2170   return c_result;
2171 }
2172
2173 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2174   if (!swig_callbackOnKeyInputFocusGained) {
2175     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2176     return;
2177   } else {
2178     swig_callbackOnKeyInputFocusGained();
2179   }
2180 }
2181
2182 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2183   if (!swig_callbackOnKeyInputFocusLost) {
2184     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2185     return;
2186   } else {
2187     swig_callbackOnKeyInputFocusLost();
2188   }
2189 }
2190
2191 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2192   Dali::Actor c_result ;
2193   void * jresult = 0 ;
2194   void * jcurrentFocusedActor  ;
2195   int jdirection  ;
2196   unsigned int jloopEnabled  ;
2197
2198   if (!swig_callbackGetNextKeyboardFocusableActor) {
2199     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2200   } else {
2201     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2202     jdirection = (int)direction;
2203     jloopEnabled = loopEnabled;
2204     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2205     if (!jresult) {
2206       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2207       return c_result;
2208     }
2209     c_result = *(Dali::Actor *)jresult;
2210   }
2211   return c_result;
2212 }
2213
2214 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2215   void * jcommitedFocusableActor  ;
2216
2217   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2218     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2219     return;
2220   } else {
2221     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2222     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2223   }
2224 }
2225
2226 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2227   bool c_result = SwigValueInit< bool >() ;
2228   unsigned int jresult = 0 ;
2229
2230   if (!swig_callbackOnKeyboardEnter) {
2231     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2232   } else {
2233     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2234     c_result = jresult ? true : false;
2235   }
2236   return c_result;
2237 }
2238
2239 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2240   void * jpinch = 0 ;
2241
2242   if (!swig_callbackOnPinch) {
2243     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2244     return;
2245   } else {
2246     jpinch = (Dali::PinchGesture *) &pinch;
2247     swig_callbackOnPinch(jpinch);
2248   }
2249 }
2250
2251 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2252   void * jpan = 0 ;
2253
2254   if (!swig_callbackOnPan) {
2255     Dali::Toolkit::Internal::Control::OnPan(pan);
2256     return;
2257   } else {
2258     jpan = (Dali::PanGesture *) &pan;
2259     swig_callbackOnPan(jpan);
2260   }
2261 }
2262
2263 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2264   void * jtap = 0 ;
2265
2266   if (!swig_callbackOnTap) {
2267     Dali::Toolkit::Internal::Control::OnTap(tap);
2268     return;
2269   } else {
2270     jtap = (Dali::TapGesture *) &tap;
2271     swig_callbackOnTap(jtap);
2272   }
2273 }
2274
2275 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2276   void * jlongPress = 0 ;
2277
2278   if (!swig_callbackOnLongPress) {
2279     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2280     return;
2281   } else {
2282     jlongPress = (Dali::LongPressGesture *) &longPress;
2283     swig_callbackOnLongPress(jlongPress);
2284   }
2285 }
2286
2287 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2288   void * jslotObserver = 0 ;
2289   void * jcallback = 0 ;
2290
2291   if (!swig_callbackSignalConnected) {
2292     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2293     return;
2294   } else {
2295     jslotObserver = (void *) slotObserver;
2296     jcallback = (void *) callback;
2297     swig_callbackSignalConnected(jslotObserver, jcallback);
2298   }
2299 }
2300
2301 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2302   void * jslotObserver = 0 ;
2303   void * jcallback = 0 ;
2304
2305   if (!swig_callbackSignalDisconnected) {
2306     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2307     return;
2308   } else {
2309     jslotObserver = (void *) slotObserver;
2310     jcallback = (void *) callback;
2311     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2312   }
2313 }
2314
2315 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2316   return Dali::Toolkit::Internal::Control::GetControlExtension();
2317 }
2318
2319 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2320   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2321   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2322   swig_callbackOnChildAdd = callbackOnChildAdd;
2323   swig_callbackOnChildRemove = callbackOnChildRemove;
2324   swig_callbackOnPropertySet = callbackOnPropertySet;
2325   swig_callbackOnSizeSet = callbackOnSizeSet;
2326   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2327   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2328   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2329   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2330   swig_callbackOnRelayout = callbackOnRelayout;
2331   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2332   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2333   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2334   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2335   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2336   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2337   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2338   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2339   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2340   swig_callbackOnInitialize = callbackOnInitialize;
2341   swig_callbackOnStyleChange = callbackOnStyleChange;
2342   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2343   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2344   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2345   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2346   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2347   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2348   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2349   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2350   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2351   swig_callbackOnPinch = callbackOnPinch;
2352   swig_callbackOnPan = callbackOnPan;
2353   swig_callbackOnTap = callbackOnTap;
2354   swig_callbackOnLongPress = callbackOnLongPress;
2355   swig_callbackSignalConnected = callbackSignalConnected;
2356   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2357 }
2358
2359 void SwigDirector_ViewImpl::swig_init_callbacks() {
2360   swig_callbackOnSceneConnection = 0;
2361   swig_callbackOnSceneDisconnection = 0;
2362   swig_callbackOnChildAdd = 0;
2363   swig_callbackOnChildRemove = 0;
2364   swig_callbackOnPropertySet = 0;
2365   swig_callbackOnSizeSet = 0;
2366   swig_callbackOnSizeAnimation = 0;
2367   swig_callbackOnHoverEvent = 0;
2368   swig_callbackOnKeyEvent = 0;
2369   swig_callbackOnWheelEvent = 0;
2370   swig_callbackOnRelayout = 0;
2371   swig_callbackOnSetResizePolicy = 0;
2372   swig_callbackGetNaturalSize = 0;
2373   swig_callbackCalculateChildSize = 0;
2374   swig_callbackGetHeightForWidth = 0;
2375   swig_callbackGetWidthForHeight = 0;
2376   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2377   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2378   swig_callbackOnCalculateRelayoutSize = 0;
2379   swig_callbackOnLayoutNegotiated = 0;
2380   swig_callbackOnInitialize = 0;
2381   swig_callbackOnStyleChange = 0;
2382   swig_callbackOnAccessibilityActivated = 0;
2383   swig_callbackOnAccessibilityPan = 0;
2384   swig_callbackOnAccessibilityValueChange = 0;
2385   swig_callbackOnAccessibilityZoom = 0;
2386   swig_callbackOnKeyInputFocusGained = 0;
2387   swig_callbackOnKeyInputFocusLost = 0;
2388   swig_callbackGetNextKeyboardFocusableActor = 0;
2389   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2390   swig_callbackOnKeyboardEnter = 0;
2391   swig_callbackOnPinch = 0;
2392   swig_callbackOnPan = 0;
2393   swig_callbackOnTap = 0;
2394   swig_callbackOnLongPress = 0;
2395   swig_callbackSignalConnected = 0;
2396   swig_callbackSignalDisconnected = 0;
2397 }
2398
2399 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2400   swig_init_callbacks();
2401 }
2402
2403 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2404
2405 }
2406
2407
2408 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2409   unsigned int c_result = SwigValueInit< unsigned int >() ;
2410   unsigned int jresult = 0 ;
2411
2412   if (!swig_callbackGetNumberOfItems) {
2413     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2414   } else {
2415     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2416     c_result = (unsigned int)jresult;
2417   }
2418   return c_result;
2419 }
2420
2421 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2422   Dali::Actor c_result ;
2423   void * jresult = 0 ;
2424   unsigned int jitemId  ;
2425
2426   if (!swig_callbackNewItem) {
2427     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2428   } else {
2429     jitemId = itemId;
2430     jresult = (void *) swig_callbackNewItem(jitemId);
2431     if (!jresult) {
2432       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2433       return c_result;
2434     }
2435     c_result = *(Dali::Actor *)jresult;
2436   }
2437   return c_result;
2438 }
2439
2440 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2441   unsigned int jitemId  ;
2442   void * jactor  ;
2443
2444   if (!swig_callbackItemReleased) {
2445     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2446     return;
2447   } else {
2448     jitemId = itemId;
2449     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2450     swig_callbackItemReleased(jitemId, jactor);
2451   }
2452 }
2453
2454 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2455   return Dali::Toolkit::ItemFactory::GetExtension();
2456 }
2457
2458 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2459   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2460   swig_callbackNewItem = callbackNewItem;
2461   swig_callbackItemReleased = callbackItemReleased;
2462 }
2463
2464 void SwigDirector_ItemFactory::swig_init_callbacks() {
2465   swig_callbackGetNumberOfItems = 0;
2466   swig_callbackNewItem = 0;
2467   swig_callbackItemReleased = 0;
2468 }
2469
2470 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2471   swig_init_callbacks();
2472 }
2473
2474 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2475
2476 }
2477
2478
2479 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2480   Dali::Actor c_result ;
2481   void * jresult = 0 ;
2482   void * jcurrent  ;
2483   void * jproposed  ;
2484   int jdirection  ;
2485
2486   if (!swig_callbackGetNextFocusableActor) {
2487     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2488   } else {
2489     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2490     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2491     jdirection = (int)direction;
2492     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2493     if (!jresult) {
2494       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2495       return c_result;
2496     }
2497     c_result = *(Dali::Actor *)jresult;
2498   }
2499   return c_result;
2500 }
2501
2502 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2503   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2504 }
2505
2506 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2507   swig_callbackGetNextFocusableActor = 0;
2508 }
2509
2510 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2511   swig_callbackOnUpdate = 0;
2512 }
2513
2514 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2515
2516 }
2517
2518 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2519   swig_callbackOnUpdate = callbackUpdate;
2520 }
2521
2522
2523 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2524   void * jcurrent  ;
2525
2526   if (!swig_callbackOnUpdate) {
2527     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2528   } else {
2529     Dali::UpdateProxy* proxy = &updateProxy;
2530     jcurrent = (void *)proxy;
2531     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2532     if (!jcurrent) {
2533       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2534       return;
2535     }
2536   }
2537   return;
2538 }
2539
2540
2541 #ifdef __cplusplus
2542 extern "C" {
2543 #endif
2544
2545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2546   void * jresult ;
2547   floatp *result = 0 ;
2548
2549   {
2550     try {
2551       result = (floatp *)new_floatp();
2552     } catch (std::out_of_range& e) {
2553       {
2554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2555       };
2556     } catch (std::exception& e) {
2557       {
2558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2559       };
2560     } catch (DaliException e) {
2561       {
2562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2563       };
2564     } catch (...) {
2565       {
2566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2567       };
2568     }
2569   }
2570   jresult = (void *)result;
2571   return jresult;
2572 }
2573
2574
2575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2576   floatp *arg1 = (floatp *) 0 ;
2577
2578   arg1 = (floatp *)jarg1;
2579   {
2580     try {
2581       delete_floatp(arg1);
2582     } catch (std::out_of_range& e) {
2583       {
2584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2585       };
2586     } catch (std::exception& e) {
2587       {
2588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2589       };
2590     } catch (Dali::DaliException e) {
2591       {
2592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2593       };
2594     } catch (...) {
2595       {
2596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2597       };
2598     }
2599   }
2600
2601 }
2602
2603
2604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2605   floatp *arg1 = (floatp *) 0 ;
2606   float arg2 ;
2607
2608   arg1 = (floatp *)jarg1;
2609   arg2 = (float)jarg2;
2610   {
2611     try {
2612       floatp_assign(arg1,arg2);
2613     } catch (std::out_of_range& e) {
2614       {
2615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2616       };
2617     } catch (std::exception& e) {
2618       {
2619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2620       };
2621     } catch (Dali::DaliException e) {
2622       {
2623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2624       };
2625     } catch (...) {
2626       {
2627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2628       };
2629     }
2630   }
2631
2632 }
2633
2634
2635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2636   float jresult ;
2637   floatp *arg1 = (floatp *) 0 ;
2638   float result;
2639
2640   arg1 = (floatp *)jarg1;
2641   {
2642     try {
2643       result = (float)floatp_value(arg1);
2644     } catch (std::out_of_range& e) {
2645       {
2646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2647       };
2648     } catch (std::exception& e) {
2649       {
2650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2651       };
2652     } catch (DaliException e) {
2653       {
2654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2655       };
2656     } catch (...) {
2657       {
2658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2659       };
2660     }
2661   }
2662   jresult = result;
2663   return jresult;
2664 }
2665
2666
2667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2668   void * jresult ;
2669   floatp *arg1 = (floatp *) 0 ;
2670   float *result = 0 ;
2671
2672   arg1 = (floatp *)jarg1;
2673   {
2674     try {
2675       result = (float *)floatp_cast(arg1);
2676     } catch (std::out_of_range& e) {
2677       {
2678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2679       };
2680     } catch (std::exception& e) {
2681       {
2682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2683       };
2684     } catch (Dali::DaliException e) {
2685       {
2686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2687       };
2688     } catch (...) {
2689       {
2690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2691       };
2692     }
2693   }
2694
2695   jresult = (void *)result;
2696   return jresult;
2697 }
2698
2699
2700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2701   void * jresult ;
2702   float *arg1 = (float *) 0 ;
2703   floatp *result = 0 ;
2704
2705   arg1 = (float *)jarg1;
2706   {
2707     try {
2708       result = (floatp *)floatp_frompointer(arg1);
2709     } catch (std::out_of_range& e) {
2710       {
2711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2712       };
2713     } catch (std::exception& e) {
2714       {
2715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2716       };
2717     } catch (Dali::DaliException e) {
2718       {
2719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2720       };
2721     } catch (...) {
2722       {
2723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2724       };
2725     }
2726   }
2727
2728   jresult = (void *)result;
2729   return jresult;
2730 }
2731
2732
2733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2734   void * jresult ;
2735   intp *result = 0 ;
2736
2737   {
2738     try {
2739       result = (intp *)new_intp();
2740     } catch (std::out_of_range& e) {
2741       {
2742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2743       };
2744     } catch (std::exception& e) {
2745       {
2746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2747       };
2748     } catch (Dali::DaliException e) {
2749       {
2750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2751       };
2752     } catch (...) {
2753       {
2754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2755       };
2756     }
2757   }
2758
2759   jresult = (void *)result;
2760   return jresult;
2761 }
2762
2763
2764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2765   intp *arg1 = (intp *) 0 ;
2766
2767   arg1 = (intp *)jarg1;
2768   {
2769     try {
2770       delete_intp(arg1);
2771     } catch (std::out_of_range& e) {
2772       {
2773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2774       };
2775     } catch (std::exception& e) {
2776       {
2777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2778       };
2779     } catch (Dali::DaliException e) {
2780       {
2781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2782       };
2783     } catch (...) {
2784       {
2785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2786       };
2787     }
2788   }
2789
2790 }
2791
2792
2793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2794   intp *arg1 = (intp *) 0 ;
2795   int arg2 ;
2796
2797   arg1 = (intp *)jarg1;
2798   arg2 = (int)jarg2;
2799   {
2800     try {
2801       intp_assign(arg1,arg2);
2802     } catch (std::out_of_range& e) {
2803       {
2804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2805       };
2806     } catch (std::exception& e) {
2807       {
2808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2809       };
2810     } catch (Dali::DaliException e) {
2811       {
2812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2813       };
2814     } catch (...) {
2815       {
2816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2817       };
2818     }
2819   }
2820
2821 }
2822
2823
2824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2825   int jresult ;
2826   intp *arg1 = (intp *) 0 ;
2827   int result;
2828
2829   arg1 = (intp *)jarg1;
2830   {
2831     try {
2832       result = (int)intp_value(arg1);
2833     } catch (std::out_of_range& e) {
2834       {
2835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2836       };
2837     } catch (std::exception& e) {
2838       {
2839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2840       };
2841     } catch (Dali::DaliException e) {
2842       {
2843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2844       };
2845     } catch (...) {
2846       {
2847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2848       };
2849     }
2850   }
2851
2852   jresult = result;
2853   return jresult;
2854 }
2855
2856
2857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2858   void * jresult ;
2859   intp *arg1 = (intp *) 0 ;
2860   int *result = 0 ;
2861
2862   arg1 = (intp *)jarg1;
2863   {
2864     try {
2865       result = (int *)intp_cast(arg1);
2866     } catch (std::out_of_range& e) {
2867       {
2868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2869       };
2870     } catch (std::exception& e) {
2871       {
2872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2873       };
2874     } catch (Dali::DaliException e) {
2875       {
2876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2877       };
2878     } catch (...) {
2879       {
2880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2881       };
2882     }
2883   }
2884
2885   jresult = (void *)result;
2886   return jresult;
2887 }
2888
2889
2890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2891   void * jresult ;
2892   int *arg1 = (int *) 0 ;
2893   intp *result = 0 ;
2894
2895   arg1 = (int *)jarg1;
2896   {
2897     try {
2898       result = (intp *)intp_frompointer(arg1);
2899     } catch (std::out_of_range& e) {
2900       {
2901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2902       };
2903     } catch (std::exception& e) {
2904       {
2905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2906       };
2907     } catch (Dali::DaliException e) {
2908       {
2909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2910       };
2911     } catch (...) {
2912       {
2913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2914       };
2915     }
2916   }
2917
2918   jresult = (void *)result;
2919   return jresult;
2920 }
2921
2922
2923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2924   void * jresult ;
2925   doublep *result = 0 ;
2926
2927   {
2928     try {
2929       result = (doublep *)new_doublep();
2930     } catch (std::out_of_range& e) {
2931       {
2932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2933       };
2934     } catch (std::exception& e) {
2935       {
2936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2937       };
2938     } catch (Dali::DaliException e) {
2939       {
2940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2941       };
2942     } catch (...) {
2943       {
2944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2945       };
2946     }
2947   }
2948
2949   jresult = (void *)result;
2950   return jresult;
2951 }
2952
2953
2954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2955   doublep *arg1 = (doublep *) 0 ;
2956
2957   arg1 = (doublep *)jarg1;
2958   {
2959     try {
2960       delete_doublep(arg1);
2961     } catch (std::out_of_range& e) {
2962       {
2963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2964       };
2965     } catch (std::exception& e) {
2966       {
2967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2968       };
2969     } catch (Dali::DaliException e) {
2970       {
2971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2972       };
2973     } catch (...) {
2974       {
2975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2976       };
2977     }
2978   }
2979
2980 }
2981
2982
2983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2984   doublep *arg1 = (doublep *) 0 ;
2985   double arg2 ;
2986
2987   arg1 = (doublep *)jarg1;
2988   arg2 = (double)jarg2;
2989   {
2990     try {
2991       doublep_assign(arg1,arg2);
2992     } catch (std::out_of_range& e) {
2993       {
2994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2995       };
2996     } catch (std::exception& e) {
2997       {
2998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2999       };
3000     } catch (Dali::DaliException e) {
3001       {
3002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3003       };
3004     } catch (...) {
3005       {
3006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3007       };
3008     }
3009   }
3010
3011 }
3012
3013
3014 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3015   double jresult ;
3016   doublep *arg1 = (doublep *) 0 ;
3017   double result;
3018
3019   arg1 = (doublep *)jarg1;
3020   {
3021     try {
3022       result = (double)doublep_value(arg1);
3023     } catch (std::out_of_range& e) {
3024       {
3025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3026       };
3027     } catch (std::exception& e) {
3028       {
3029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3030       };
3031     } catch (Dali::DaliException e) {
3032       {
3033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3034       };
3035     } catch (...) {
3036       {
3037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3038       };
3039     }
3040   }
3041
3042   jresult = result;
3043   return jresult;
3044 }
3045
3046
3047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3048   void * jresult ;
3049   doublep *arg1 = (doublep *) 0 ;
3050   double *result = 0 ;
3051
3052   arg1 = (doublep *)jarg1;
3053   {
3054     try {
3055       result = (double *)doublep_cast(arg1);
3056     } catch (std::out_of_range& e) {
3057       {
3058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3059       };
3060     } catch (std::exception& e) {
3061       {
3062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3063       };
3064     } catch (Dali::DaliException e) {
3065       {
3066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3067       };
3068     } catch (...) {
3069       {
3070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3071       };
3072     }
3073   }
3074
3075   jresult = (void *)result;
3076   return jresult;
3077 }
3078
3079
3080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3081   void * jresult ;
3082   double *arg1 = (double *) 0 ;
3083   doublep *result = 0 ;
3084
3085   arg1 = (double *)jarg1;
3086   {
3087     try {
3088       result = (doublep *)doublep_frompointer(arg1);
3089     } catch (std::out_of_range& e) {
3090       {
3091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3092       };
3093     } catch (std::exception& e) {
3094       {
3095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3096       };
3097     } catch (Dali::DaliException e) {
3098       {
3099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3100       };
3101     } catch (...) {
3102       {
3103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3104       };
3105     }
3106   }
3107
3108   jresult = (void *)result;
3109   return jresult;
3110 }
3111
3112
3113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3114   void * jresult ;
3115   uintp *result = 0 ;
3116
3117   {
3118     try {
3119       result = (uintp *)new_uintp();
3120     } catch (std::out_of_range& e) {
3121       {
3122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3123       };
3124     } catch (std::exception& e) {
3125       {
3126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3127       };
3128     } catch (Dali::DaliException e) {
3129       {
3130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3131       };
3132     } catch (...) {
3133       {
3134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3135       };
3136     }
3137   }
3138
3139   jresult = (void *)result;
3140   return jresult;
3141 }
3142
3143
3144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3145   uintp *arg1 = (uintp *) 0 ;
3146
3147   arg1 = (uintp *)jarg1;
3148   {
3149     try {
3150       delete_uintp(arg1);
3151     } catch (std::out_of_range& e) {
3152       {
3153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3154       };
3155     } catch (std::exception& e) {
3156       {
3157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3158       };
3159     } catch (Dali::DaliException e) {
3160       {
3161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3162       };
3163     } catch (...) {
3164       {
3165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3166       };
3167     }
3168   }
3169
3170 }
3171
3172
3173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3174   uintp *arg1 = (uintp *) 0 ;
3175   unsigned int arg2 ;
3176
3177   arg1 = (uintp *)jarg1;
3178   arg2 = (unsigned int)jarg2;
3179   {
3180     try {
3181       uintp_assign(arg1,arg2);
3182     } catch (std::out_of_range& e) {
3183       {
3184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3185       };
3186     } catch (std::exception& e) {
3187       {
3188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3189       };
3190     } catch (Dali::DaliException e) {
3191       {
3192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3193       };
3194     } catch (...) {
3195       {
3196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3197       };
3198     }
3199   }
3200
3201 }
3202
3203
3204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3205   unsigned int jresult ;
3206   uintp *arg1 = (uintp *) 0 ;
3207   unsigned int result;
3208
3209   arg1 = (uintp *)jarg1;
3210   {
3211     try {
3212       result = (unsigned int)uintp_value(arg1);
3213     } catch (std::out_of_range& e) {
3214       {
3215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3216       };
3217     } catch (std::exception& e) {
3218       {
3219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3220       };
3221     } catch (Dali::DaliException e) {
3222       {
3223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3224       };
3225     } catch (...) {
3226       {
3227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3228       };
3229     }
3230   }
3231
3232   jresult = result;
3233   return jresult;
3234 }
3235
3236
3237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3238   void * jresult ;
3239   uintp *arg1 = (uintp *) 0 ;
3240   unsigned int *result = 0 ;
3241
3242   arg1 = (uintp *)jarg1;
3243   {
3244     try {
3245       result = (unsigned int *)uintp_cast(arg1);
3246     } catch (std::out_of_range& e) {
3247       {
3248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3249       };
3250     } catch (std::exception& e) {
3251       {
3252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3253       };
3254     } catch (Dali::DaliException e) {
3255       {
3256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3257       };
3258     } catch (...) {
3259       {
3260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3261       };
3262     }
3263   }
3264
3265   jresult = (void *)result;
3266   return jresult;
3267 }
3268
3269
3270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3271   void * jresult ;
3272   unsigned int *arg1 = (unsigned int *) 0 ;
3273   uintp *result = 0 ;
3274
3275   arg1 = (unsigned int *)jarg1;
3276   {
3277     try {
3278       result = (uintp *)uintp_frompointer(arg1);
3279     } catch (std::out_of_range& e) {
3280       {
3281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3282       };
3283     } catch (std::exception& e) {
3284       {
3285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3286       };
3287     } catch (Dali::DaliException e) {
3288       {
3289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3290       };
3291     } catch (...) {
3292       {
3293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3294       };
3295     }
3296   }
3297
3298   jresult = (void *)result;
3299   return jresult;
3300 }
3301
3302
3303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3304   void * jresult ;
3305   ushortp *result = 0 ;
3306
3307   {
3308     try {
3309       result = (ushortp *)new_ushortp();
3310     } catch (std::out_of_range& e) {
3311       {
3312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3313       };
3314     } catch (std::exception& e) {
3315       {
3316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3317       };
3318     } catch (Dali::DaliException e) {
3319       {
3320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3321       };
3322     } catch (...) {
3323       {
3324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3325       };
3326     }
3327   }
3328
3329   jresult = (void *)result;
3330   return jresult;
3331 }
3332
3333
3334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3335   ushortp *arg1 = (ushortp *) 0 ;
3336
3337   arg1 = (ushortp *)jarg1;
3338   {
3339     try {
3340       delete_ushortp(arg1);
3341     } catch (std::out_of_range& e) {
3342       {
3343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3344       };
3345     } catch (std::exception& e) {
3346       {
3347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3348       };
3349     } catch (Dali::DaliException e) {
3350       {
3351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3352       };
3353     } catch (...) {
3354       {
3355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3356       };
3357     }
3358   }
3359
3360 }
3361
3362
3363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3364   ushortp *arg1 = (ushortp *) 0 ;
3365   unsigned short arg2 ;
3366
3367   arg1 = (ushortp *)jarg1;
3368   arg2 = (unsigned short)jarg2;
3369   {
3370     try {
3371       ushortp_assign(arg1,arg2);
3372     } catch (std::out_of_range& e) {
3373       {
3374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3375       };
3376     } catch (std::exception& e) {
3377       {
3378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3379       };
3380     } catch (Dali::DaliException e) {
3381       {
3382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3383       };
3384     } catch (...) {
3385       {
3386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3387       };
3388     }
3389   }
3390
3391 }
3392
3393
3394 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3395   unsigned short jresult ;
3396   ushortp *arg1 = (ushortp *) 0 ;
3397   unsigned short result;
3398
3399   arg1 = (ushortp *)jarg1;
3400   {
3401     try {
3402       result = (unsigned short)ushortp_value(arg1);
3403     } catch (std::out_of_range& e) {
3404       {
3405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3406       };
3407     } catch (std::exception& e) {
3408       {
3409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3410       };
3411     } catch (Dali::DaliException e) {
3412       {
3413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3414       };
3415     } catch (...) {
3416       {
3417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3418       };
3419     }
3420   }
3421
3422   jresult = result;
3423   return jresult;
3424 }
3425
3426
3427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3428   void * jresult ;
3429   ushortp *arg1 = (ushortp *) 0 ;
3430   unsigned short *result = 0 ;
3431
3432   arg1 = (ushortp *)jarg1;
3433   {
3434     try {
3435       result = (unsigned short *)ushortp_cast(arg1);
3436     } catch (std::out_of_range& e) {
3437       {
3438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3439       };
3440     } catch (std::exception& e) {
3441       {
3442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3443       };
3444     } catch (Dali::DaliException e) {
3445       {
3446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3447       };
3448     } catch (...) {
3449       {
3450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3451       };
3452     }
3453   }
3454
3455   jresult = (void *)result;
3456   return jresult;
3457 }
3458
3459
3460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3461   void * jresult ;
3462   unsigned short *arg1 = (unsigned short *) 0 ;
3463   ushortp *result = 0 ;
3464
3465   arg1 = (unsigned short *)jarg1;
3466   {
3467     try {
3468       result = (ushortp *)ushortp_frompointer(arg1);
3469     } catch (std::out_of_range& e) {
3470       {
3471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3472       };
3473     } catch (std::exception& e) {
3474       {
3475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3476       };
3477     } catch (Dali::DaliException e) {
3478       {
3479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3480       };
3481     } catch (...) {
3482       {
3483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3484       };
3485     }
3486   }
3487
3488   jresult = (void *)result;
3489   return jresult;
3490 }
3491
3492
3493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3494   unsigned int jresult ;
3495   int arg1 ;
3496   unsigned int result;
3497
3498   arg1 = (int)jarg1;
3499   {
3500     try {
3501       result = (unsigned int)int_to_uint(arg1);
3502     } catch (std::out_of_range& e) {
3503       {
3504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3505       };
3506     } catch (std::exception& e) {
3507       {
3508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3509       };
3510     } catch (Dali::DaliException e) {
3511       {
3512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3513       };
3514     } catch (...) {
3515       {
3516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3517       };
3518     }
3519   }
3520
3521   jresult = result;
3522   return jresult;
3523 }
3524
3525
3526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3527   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3528
3529   arg1 = (Dali::RefObject *)jarg1;
3530   {
3531     try {
3532       (arg1)->Reference();
3533     } catch (std::out_of_range& e) {
3534       {
3535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3536       };
3537     } catch (std::exception& e) {
3538       {
3539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3540       };
3541     } catch (Dali::DaliException e) {
3542       {
3543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3544       };
3545     } catch (...) {
3546       {
3547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3548       };
3549     }
3550   }
3551
3552 }
3553
3554
3555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3556   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3557
3558   arg1 = (Dali::RefObject *)jarg1;
3559   {
3560     try {
3561       (arg1)->Unreference();
3562     } catch (std::out_of_range& e) {
3563       {
3564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3565       };
3566     } catch (std::exception& e) {
3567       {
3568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3569       };
3570     } catch (Dali::DaliException e) {
3571       {
3572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3573       };
3574     } catch (...) {
3575       {
3576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3577       };
3578     }
3579   }
3580
3581 }
3582
3583
3584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3585   int jresult ;
3586   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3587   int result;
3588
3589   arg1 = (Dali::RefObject *)jarg1;
3590   {
3591     try {
3592       result = (int)(arg1)->ReferenceCount();
3593     } catch (std::out_of_range& e) {
3594       {
3595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3596       };
3597     } catch (std::exception& e) {
3598       {
3599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3600       };
3601     } catch (Dali::DaliException e) {
3602       {
3603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3604       };
3605     } catch (...) {
3606       {
3607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3608       };
3609     }
3610   }
3611
3612   jresult = result;
3613   return jresult;
3614 }
3615
3616
3617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3618   void * jresult ;
3619   Dali::Any *result = 0 ;
3620
3621   {
3622     try {
3623       result = (Dali::Any *)new Dali::Any();
3624     } catch (std::out_of_range& e) {
3625       {
3626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3627       };
3628     } catch (std::exception& e) {
3629       {
3630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3631       };
3632     } catch (Dali::DaliException e) {
3633       {
3634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3635       };
3636     } catch (...) {
3637       {
3638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3639       };
3640     }
3641   }
3642
3643   jresult = (void *)result;
3644   return jresult;
3645 }
3646
3647
3648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3649   Dali::Any *arg1 = (Dali::Any *) 0 ;
3650
3651   arg1 = (Dali::Any *)jarg1;
3652   {
3653     try {
3654       delete arg1;
3655     } catch (std::out_of_range& e) {
3656       {
3657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3658       };
3659     } catch (std::exception& e) {
3660       {
3661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3662       };
3663     } catch (Dali::DaliException e) {
3664       {
3665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3666       };
3667     } catch (...) {
3668       {
3669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3670       };
3671     }
3672   }
3673
3674 }
3675
3676
3677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3678   char *arg1 = (char *) 0 ;
3679
3680   arg1 = (char *)jarg1;
3681   {
3682     try {
3683       Dali::Any::AssertAlways((char const *)arg1);
3684     } catch (std::out_of_range& e) {
3685       {
3686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3687       };
3688     } catch (std::exception& e) {
3689       {
3690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3691       };
3692     } catch (Dali::DaliException e) {
3693       {
3694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3695       };
3696     } catch (...) {
3697       {
3698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3699       };
3700     }
3701   }
3702
3703 }
3704
3705
3706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3707   void * jresult ;
3708   Dali::Any *arg1 = 0 ;
3709   Dali::Any *result = 0 ;
3710
3711   arg1 = (Dali::Any *)jarg1;
3712   if (!arg1) {
3713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3714     return 0;
3715   }
3716   {
3717     try {
3718       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3719     } catch (std::out_of_range& e) {
3720       {
3721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3722       };
3723     } catch (std::exception& e) {
3724       {
3725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3726       };
3727     } catch (Dali::DaliException e) {
3728       {
3729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3730       };
3731     } catch (...) {
3732       {
3733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3734       };
3735     }
3736   }
3737
3738   jresult = (void *)result;
3739   return jresult;
3740 }
3741
3742
3743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3744   void * jresult ;
3745   Dali::Any *arg1 = (Dali::Any *) 0 ;
3746   Dali::Any *arg2 = 0 ;
3747   Dali::Any *result = 0 ;
3748
3749   arg1 = (Dali::Any *)jarg1;
3750   arg2 = (Dali::Any *)jarg2;
3751   if (!arg2) {
3752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3753     return 0;
3754   }
3755   {
3756     try {
3757       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3758     } catch (std::out_of_range& e) {
3759       {
3760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3761       };
3762     } catch (std::exception& e) {
3763       {
3764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3765       };
3766     } catch (Dali::DaliException e) {
3767       {
3768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3769       };
3770     } catch (...) {
3771       {
3772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3773       };
3774     }
3775   }
3776
3777   jresult = (void *)result;
3778   return jresult;
3779 }
3780
3781
3782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3783   void * jresult ;
3784   Dali::Any *arg1 = (Dali::Any *) 0 ;
3785   std::type_info *result = 0 ;
3786
3787   arg1 = (Dali::Any *)jarg1;
3788   {
3789     try {
3790       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3791     } catch (std::out_of_range& e) {
3792       {
3793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3794       };
3795     } catch (std::exception& e) {
3796       {
3797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3798       };
3799     } catch (Dali::DaliException e) {
3800       {
3801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3802       };
3803     } catch (...) {
3804       {
3805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3806       };
3807     }
3808   }
3809
3810   jresult = (void *)result;
3811   return jresult;
3812 }
3813
3814
3815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3816   unsigned int jresult ;
3817   Dali::Any *arg1 = (Dali::Any *) 0 ;
3818   bool result;
3819
3820   arg1 = (Dali::Any *)jarg1;
3821   {
3822     try {
3823       result = (bool)((Dali::Any const *)arg1)->Empty();
3824     } catch (std::out_of_range& e) {
3825       {
3826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3827       };
3828     } catch (std::exception& e) {
3829       {
3830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3831       };
3832     } catch (Dali::DaliException e) {
3833       {
3834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3835       };
3836     } catch (...) {
3837       {
3838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3839       };
3840     }
3841   }
3842
3843   jresult = result;
3844   return jresult;
3845 }
3846
3847
3848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3849   void * jresult ;
3850   std::type_info *arg1 = 0 ;
3851   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3852   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3853   Dali::Any::AnyContainerBase *result = 0 ;
3854
3855   arg1 = (std::type_info *)jarg1;
3856   if (!arg1) {
3857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3858     return 0;
3859   }
3860   arg2 = (Dali::Any::CloneFunc)jarg2;
3861   arg3 = (Dali::Any::DeleteFunc)jarg3;
3862   {
3863     try {
3864       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3865     } catch (std::out_of_range& e) {
3866       {
3867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3868       };
3869     } catch (std::exception& e) {
3870       {
3871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3872       };
3873     } catch (Dali::DaliException e) {
3874       {
3875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3876       };
3877     } catch (...) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3880       };
3881     }
3882   }
3883
3884   jresult = (void *)result;
3885   return jresult;
3886 }
3887
3888
3889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3890   void * jresult ;
3891   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3892   std::type_info *result = 0 ;
3893
3894   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3895   {
3896     try {
3897       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3898     } catch (std::out_of_range& e) {
3899       {
3900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3901       };
3902     } catch (std::exception& e) {
3903       {
3904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3905       };
3906     } catch (Dali::DaliException e) {
3907       {
3908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3909       };
3910     } catch (...) {
3911       {
3912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3913       };
3914     }
3915   }
3916
3917   jresult = (void *)result;
3918   return jresult;
3919 }
3920
3921
3922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3923   void * jresult ;
3924   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3925   ::std::type_info *result = 0 ;
3926
3927   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3928   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3929   jresult = (void *)result;
3930   return jresult;
3931 }
3932
3933
3934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3935   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3936   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3937
3938   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3939   arg2 = (Dali::Any::CloneFunc)jarg2;
3940   if (arg1) (arg1)->mCloneFunc = arg2;
3941 }
3942
3943
3944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3945   void * jresult ;
3946   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3947   Dali::Any::CloneFunc result;
3948
3949   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3950   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3951   jresult = (void *)result;
3952   return jresult;
3953 }
3954
3955
3956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3957   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3958   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3959
3960   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3961   arg2 = (Dali::Any::DeleteFunc)jarg2;
3962   if (arg1) (arg1)->mDeleteFunc = arg2;
3963 }
3964
3965
3966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3967   void * jresult ;
3968   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3969   Dali::Any::DeleteFunc result;
3970
3971   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3972   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3973   jresult = (void *)result;
3974   return jresult;
3975 }
3976
3977
3978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3979   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3980
3981   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3982   {
3983     try {
3984       delete arg1;
3985     } catch (std::out_of_range& e) {
3986       {
3987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3988       };
3989     } catch (std::exception& e) {
3990       {
3991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3992       };
3993     } catch (Dali::DaliException e) {
3994       {
3995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3996       };
3997     } catch (...) {
3998       {
3999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4000       };
4001     }
4002   }
4003
4004 }
4005
4006
4007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4008   Dali::Any *arg1 = (Dali::Any *) 0 ;
4009   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4010
4011   arg1 = (Dali::Any *)jarg1;
4012   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4013   if (arg1) (arg1)->mContainer = arg2;
4014 }
4015
4016
4017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4018   void * jresult ;
4019   Dali::Any *arg1 = (Dali::Any *) 0 ;
4020   Dali::Any::AnyContainerBase *result = 0 ;
4021
4022   arg1 = (Dali::Any *)jarg1;
4023   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4024   jresult = (void *)result;
4025   return jresult;
4026 }
4027
4028
4029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4030   char *arg1 = (char *) 0 ;
4031   char *arg2 = (char *) 0 ;
4032
4033   arg1 = (char *)jarg1;
4034   arg2 = (char *)jarg2;
4035   {
4036     try {
4037       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4038     } catch (std::out_of_range& e) {
4039       {
4040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4041       };
4042     } catch (std::exception& e) {
4043       {
4044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4045       };
4046     } catch (Dali::DaliException e) {
4047       {
4048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4049       };
4050     } catch (...) {
4051       {
4052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4053       };
4054     }
4055   }
4056
4057 }
4058
4059
4060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4061   void * jresult ;
4062   char *arg1 = (char *) 0 ;
4063   char *arg2 = (char *) 0 ;
4064   Dali::DaliException *result = 0 ;
4065
4066   arg1 = (char *)jarg1;
4067   arg2 = (char *)jarg2;
4068   {
4069     try {
4070       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4071     } catch (std::out_of_range& e) {
4072       {
4073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4074       };
4075     } catch (std::exception& e) {
4076       {
4077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4078       };
4079     } catch (Dali::DaliException e) {
4080       {
4081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4082       };
4083     } catch (...) {
4084       {
4085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4086       };
4087     }
4088   }
4089
4090   jresult = (void *)result;
4091   return jresult;
4092 }
4093
4094
4095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4096   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4097   std::string arg2 = std::string(jarg2);
4098
4099   arg1 = (Dali::DaliException *)jarg1;
4100   {
4101     if (!arg2.empty()) {
4102       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4103     } else {
4104       arg1->location = 0;
4105     }
4106   }
4107 }
4108
4109 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4110   char * jresult ;
4111   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4112   char *result = 0 ;
4113
4114   arg1 = (Dali::DaliException *)jarg1;
4115   result = (char *) ((arg1)->location);
4116   jresult = SWIG_csharp_string_callback((const char *)result);
4117   return jresult;
4118 }
4119
4120
4121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4122   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4123   std::string arg2 = std::string(jarg2);
4124
4125   arg1 = (Dali::DaliException *)jarg1;
4126   {
4127     if (!arg2.empty()) {
4128       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4129     } else {
4130       arg1->condition = 0;
4131     }
4132   }
4133 }
4134
4135
4136 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4137   char * jresult ;
4138   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4139   char *result = 0 ;
4140
4141   arg1 = (Dali::DaliException *)jarg1;
4142   result = (char *) ((arg1)->condition);
4143   jresult = SWIG_csharp_string_callback((const char *)result);
4144   return jresult;
4145 }
4146
4147
4148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4149   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4150
4151   arg1 = (Dali::DaliException *)jarg1;
4152   {
4153     try {
4154       delete arg1;
4155     } catch (std::out_of_range& e) {
4156       {
4157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4158       };
4159     } catch (std::exception& e) {
4160       {
4161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4162       };
4163     } catch (Dali::DaliException e) {
4164       {
4165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4166       };
4167     } catch (...) {
4168       {
4169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4170       };
4171     }
4172   }
4173
4174 }
4175
4176
4177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4178   void * jresult ;
4179   Dali::Vector2 *result = 0 ;
4180
4181   {
4182     try {
4183       result = (Dali::Vector2 *)new Dali::Vector2();
4184     } catch (std::out_of_range& e) {
4185       {
4186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4187       };
4188     } catch (std::exception& e) {
4189       {
4190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4191       };
4192     } catch (Dali::DaliException e) {
4193       {
4194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4195       };
4196     } catch (...) {
4197       {
4198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4199       };
4200     }
4201   }
4202
4203   jresult = (void *)result;
4204   return jresult;
4205 }
4206
4207
4208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4209   void * jresult ;
4210   float arg1 ;
4211   float arg2 ;
4212   Dali::Vector2 *result = 0 ;
4213
4214   arg1 = (float)jarg1;
4215   arg2 = (float)jarg2;
4216   {
4217     try {
4218       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4219     } catch (std::out_of_range& e) {
4220       {
4221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4222       };
4223     } catch (std::exception& e) {
4224       {
4225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4226       };
4227     } catch (Dali::DaliException e) {
4228       {
4229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4230       };
4231     } catch (...) {
4232       {
4233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4234       };
4235     }
4236   }
4237
4238   jresult = (void *)result;
4239   return jresult;
4240 }
4241
4242
4243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4244   void * jresult ;
4245   float *arg1 = (float *) 0 ;
4246   Dali::Vector2 *result = 0 ;
4247
4248   arg1 = jarg1;
4249   {
4250     try {
4251       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4252     } catch (std::out_of_range& e) {
4253       {
4254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4255       };
4256     } catch (std::exception& e) {
4257       {
4258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4259       };
4260     } catch (Dali::DaliException e) {
4261       {
4262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4263       };
4264     } catch (...) {
4265       {
4266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4267       };
4268     }
4269   }
4270
4271   jresult = (void *)result;
4272
4273
4274   return jresult;
4275 }
4276
4277
4278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4279   void * jresult ;
4280   Dali::Vector3 *arg1 = 0 ;
4281   Dali::Vector2 *result = 0 ;
4282
4283   arg1 = (Dali::Vector3 *)jarg1;
4284   if (!arg1) {
4285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4286     return 0;
4287   }
4288   {
4289     try {
4290       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4291     } catch (std::out_of_range& e) {
4292       {
4293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4294       };
4295     } catch (std::exception& e) {
4296       {
4297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4298       };
4299     } catch (Dali::DaliException e) {
4300       {
4301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4302       };
4303     } catch (...) {
4304       {
4305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4306       };
4307     }
4308   }
4309
4310   jresult = (void *)result;
4311   return jresult;
4312 }
4313
4314
4315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4316   void * jresult ;
4317   Dali::Vector4 *arg1 = 0 ;
4318   Dali::Vector2 *result = 0 ;
4319
4320   arg1 = (Dali::Vector4 *)jarg1;
4321   if (!arg1) {
4322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4323     return 0;
4324   }
4325   {
4326     try {
4327       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4328     } catch (std::out_of_range& e) {
4329       {
4330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4331       };
4332     } catch (std::exception& e) {
4333       {
4334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4335       };
4336     } catch (Dali::DaliException e) {
4337       {
4338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4339       };
4340     } catch (...) {
4341       {
4342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4343       };
4344     }
4345   }
4346
4347   jresult = (void *)result;
4348   return jresult;
4349 }
4350
4351
4352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4353   void * jresult ;
4354   Dali::Vector2 *result = 0 ;
4355
4356   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4357   jresult = (void *)result;
4358   return jresult;
4359 }
4360
4361
4362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4363   void * jresult ;
4364   Dali::Vector2 *result = 0 ;
4365
4366   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4367   jresult = (void *)result;
4368   return jresult;
4369 }
4370
4371
4372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4373   void * jresult ;
4374   Dali::Vector2 *result = 0 ;
4375
4376   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4377   jresult = (void *)result;
4378   return jresult;
4379 }
4380
4381
4382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4383   void * jresult ;
4384   Dali::Vector2 *result = 0 ;
4385
4386   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4387   jresult = (void *)result;
4388   return jresult;
4389 }
4390
4391
4392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4393   void * jresult ;
4394   Dali::Vector2 *result = 0 ;
4395
4396   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4397   jresult = (void *)result;
4398   return jresult;
4399 }
4400
4401
4402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4403   void * jresult ;
4404   Dali::Vector2 *result = 0 ;
4405
4406   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4407   jresult = (void *)result;
4408   return jresult;
4409 }
4410
4411
4412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4413   void * jresult ;
4414   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4415   float *arg2 = (float *) 0 ;
4416   Dali::Vector2 *result = 0 ;
4417
4418   arg1 = (Dali::Vector2 *)jarg1;
4419   arg2 = jarg2;
4420   {
4421     try {
4422       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4423     } catch (std::out_of_range& e) {
4424       {
4425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4426       };
4427     } catch (std::exception& e) {
4428       {
4429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4430       };
4431     } catch (Dali::DaliException e) {
4432       {
4433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4434       };
4435     } catch (...) {
4436       {
4437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4438       };
4439     }
4440   }
4441
4442   jresult = (void *)result;
4443
4444
4445   return jresult;
4446 }
4447
4448
4449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4450   void * jresult ;
4451   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4452   Dali::Vector3 *arg2 = 0 ;
4453   Dali::Vector2 *result = 0 ;
4454
4455   arg1 = (Dali::Vector2 *)jarg1;
4456   arg2 = (Dali::Vector3 *)jarg2;
4457   if (!arg2) {
4458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4459     return 0;
4460   }
4461   {
4462     try {
4463       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4464     } catch (std::out_of_range& e) {
4465       {
4466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4467       };
4468     } catch (std::exception& e) {
4469       {
4470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4471       };
4472     } catch (Dali::DaliException e) {
4473       {
4474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4475       };
4476     } catch (...) {
4477       {
4478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4479       };
4480     }
4481   }
4482
4483   jresult = (void *)result;
4484   return jresult;
4485 }
4486
4487
4488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4489   void * jresult ;
4490   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4491   Dali::Vector4 *arg2 = 0 ;
4492   Dali::Vector2 *result = 0 ;
4493
4494   arg1 = (Dali::Vector2 *)jarg1;
4495   arg2 = (Dali::Vector4 *)jarg2;
4496   if (!arg2) {
4497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4498     return 0;
4499   }
4500   {
4501     try {
4502       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4503     } catch (std::out_of_range& e) {
4504       {
4505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4506       };
4507     } catch (std::exception& e) {
4508       {
4509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4510       };
4511     } catch (Dali::DaliException e) {
4512       {
4513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4514       };
4515     } catch (...) {
4516       {
4517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4518       };
4519     }
4520   }
4521
4522   jresult = (void *)result;
4523   return jresult;
4524 }
4525
4526
4527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4528   void * jresult ;
4529   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4530   Dali::Vector2 *arg2 = 0 ;
4531   Dali::Vector2 result;
4532
4533   arg1 = (Dali::Vector2 *)jarg1;
4534   arg2 = (Dali::Vector2 *)jarg2;
4535   if (!arg2) {
4536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4537     return 0;
4538   }
4539   {
4540     try {
4541       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4542     } catch (std::out_of_range& e) {
4543       {
4544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4545       };
4546     } catch (std::exception& e) {
4547       {
4548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4549       };
4550     } catch (Dali::DaliException e) {
4551       {
4552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4553       };
4554     } catch (...) {
4555       {
4556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4557       };
4558     }
4559   }
4560
4561   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4562   return jresult;
4563 }
4564
4565
4566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4567   void * jresult ;
4568   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4569   Dali::Vector2 *arg2 = 0 ;
4570   Dali::Vector2 *result = 0 ;
4571
4572   arg1 = (Dali::Vector2 *)jarg1;
4573   arg2 = (Dali::Vector2 *)jarg2;
4574   if (!arg2) {
4575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4576     return 0;
4577   }
4578   {
4579     try {
4580       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4581     } catch (std::out_of_range& e) {
4582       {
4583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4584       };
4585     } catch (std::exception& e) {
4586       {
4587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4588       };
4589     } catch (Dali::DaliException e) {
4590       {
4591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4592       };
4593     } catch (...) {
4594       {
4595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4596       };
4597     }
4598   }
4599
4600   jresult = (void *)result;
4601   return jresult;
4602 }
4603
4604
4605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4606   void * jresult ;
4607   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4608   Dali::Vector2 *arg2 = 0 ;
4609   Dali::Vector2 result;
4610
4611   arg1 = (Dali::Vector2 *)jarg1;
4612   arg2 = (Dali::Vector2 *)jarg2;
4613   if (!arg2) {
4614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4615     return 0;
4616   }
4617   {
4618     try {
4619       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4620     } catch (std::out_of_range& e) {
4621       {
4622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4623       };
4624     } catch (std::exception& e) {
4625       {
4626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4627       };
4628     } catch (Dali::DaliException e) {
4629       {
4630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4631       };
4632     } catch (...) {
4633       {
4634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4635       };
4636     }
4637   }
4638
4639   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4640   return jresult;
4641 }
4642
4643
4644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4645   void * jresult ;
4646   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4647   Dali::Vector2 *arg2 = 0 ;
4648   Dali::Vector2 *result = 0 ;
4649
4650   arg1 = (Dali::Vector2 *)jarg1;
4651   arg2 = (Dali::Vector2 *)jarg2;
4652   if (!arg2) {
4653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4654     return 0;
4655   }
4656   {
4657     try {
4658       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4659     } catch (std::out_of_range& e) {
4660       {
4661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4662       };
4663     } catch (std::exception& e) {
4664       {
4665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4666       };
4667     } catch (Dali::DaliException e) {
4668       {
4669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4670       };
4671     } catch (...) {
4672       {
4673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4674       };
4675     }
4676   }
4677
4678   jresult = (void *)result;
4679   return jresult;
4680 }
4681
4682
4683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4684   void * jresult ;
4685   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4686   Dali::Vector2 *arg2 = 0 ;
4687   Dali::Vector2 result;
4688
4689   arg1 = (Dali::Vector2 *)jarg1;
4690   arg2 = (Dali::Vector2 *)jarg2;
4691   if (!arg2) {
4692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4693     return 0;
4694   }
4695   {
4696     try {
4697       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4698     } catch (std::out_of_range& e) {
4699       {
4700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4701       };
4702     } catch (std::exception& e) {
4703       {
4704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4705       };
4706     } catch (Dali::DaliException e) {
4707       {
4708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4709       };
4710     } catch (...) {
4711       {
4712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4713       };
4714     }
4715   }
4716
4717   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4718   return jresult;
4719 }
4720
4721
4722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4723   void * jresult ;
4724   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4725   float arg2 ;
4726   Dali::Vector2 result;
4727
4728   arg1 = (Dali::Vector2 *)jarg1;
4729   arg2 = (float)jarg2;
4730   {
4731     try {
4732       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4733     } catch (std::out_of_range& e) {
4734       {
4735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4736       };
4737     } catch (std::exception& e) {
4738       {
4739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4740       };
4741     } catch (Dali::DaliException e) {
4742       {
4743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4744       };
4745     } catch (...) {
4746       {
4747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4748       };
4749     }
4750   }
4751
4752   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4753   return jresult;
4754 }
4755
4756
4757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4758   void * jresult ;
4759   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4760   Dali::Vector2 *arg2 = 0 ;
4761   Dali::Vector2 *result = 0 ;
4762
4763   arg1 = (Dali::Vector2 *)jarg1;
4764   arg2 = (Dali::Vector2 *)jarg2;
4765   if (!arg2) {
4766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4767     return 0;
4768   }
4769   {
4770     try {
4771       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4772     } catch (std::out_of_range& e) {
4773       {
4774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4775       };
4776     } catch (std::exception& e) {
4777       {
4778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4779       };
4780     } catch (Dali::DaliException e) {
4781       {
4782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4783       };
4784     } catch (...) {
4785       {
4786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4787       };
4788     }
4789   }
4790
4791   jresult = (void *)result;
4792   return jresult;
4793 }
4794
4795
4796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4797   void * jresult ;
4798   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4799   float arg2 ;
4800   Dali::Vector2 *result = 0 ;
4801
4802   arg1 = (Dali::Vector2 *)jarg1;
4803   arg2 = (float)jarg2;
4804   {
4805     try {
4806       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4807     } catch (std::out_of_range& e) {
4808       {
4809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4810       };
4811     } catch (std::exception& e) {
4812       {
4813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4814       };
4815     } catch (Dali::DaliException e) {
4816       {
4817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4818       };
4819     } catch (...) {
4820       {
4821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4822       };
4823     }
4824   }
4825
4826   jresult = (void *)result;
4827   return jresult;
4828 }
4829
4830
4831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4832   void * jresult ;
4833   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4834   Dali::Vector2 *arg2 = 0 ;
4835   Dali::Vector2 result;
4836
4837   arg1 = (Dali::Vector2 *)jarg1;
4838   arg2 = (Dali::Vector2 *)jarg2;
4839   if (!arg2) {
4840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4841     return 0;
4842   }
4843   {
4844     try {
4845       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4846     } catch (std::out_of_range& e) {
4847       {
4848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4849       };
4850     } catch (std::exception& e) {
4851       {
4852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4853       };
4854     } catch (Dali::DaliException e) {
4855       {
4856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4857       };
4858     } catch (...) {
4859       {
4860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4861       };
4862     }
4863   }
4864
4865   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4866   return jresult;
4867 }
4868
4869
4870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4871   void * jresult ;
4872   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4873   float arg2 ;
4874   Dali::Vector2 result;
4875
4876   arg1 = (Dali::Vector2 *)jarg1;
4877   arg2 = (float)jarg2;
4878   {
4879     try {
4880       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4881     } catch (std::out_of_range& e) {
4882       {
4883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4884       };
4885     } catch (std::exception& e) {
4886       {
4887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4888       };
4889     } catch (Dali::DaliException e) {
4890       {
4891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4892       };
4893     } catch (...) {
4894       {
4895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4896       };
4897     }
4898   }
4899
4900   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4901   return jresult;
4902 }
4903
4904
4905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4906   void * jresult ;
4907   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4908   Dali::Vector2 *arg2 = 0 ;
4909   Dali::Vector2 *result = 0 ;
4910
4911   arg1 = (Dali::Vector2 *)jarg1;
4912   arg2 = (Dali::Vector2 *)jarg2;
4913   if (!arg2) {
4914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4915     return 0;
4916   }
4917   {
4918     try {
4919       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4920     } catch (std::out_of_range& e) {
4921       {
4922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4923       };
4924     } catch (std::exception& e) {
4925       {
4926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4927       };
4928     } catch (Dali::DaliException e) {
4929       {
4930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4931       };
4932     } catch (...) {
4933       {
4934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4935       };
4936     }
4937   }
4938
4939   jresult = (void *)result;
4940   return jresult;
4941 }
4942
4943
4944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4945   void * jresult ;
4946   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4947   float arg2 ;
4948   Dali::Vector2 *result = 0 ;
4949
4950   arg1 = (Dali::Vector2 *)jarg1;
4951   arg2 = (float)jarg2;
4952   {
4953     try {
4954       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4955     } catch (std::out_of_range& e) {
4956       {
4957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4958       };
4959     } catch (std::exception& e) {
4960       {
4961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4962       };
4963     } catch (Dali::DaliException e) {
4964       {
4965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4966       };
4967     } catch (...) {
4968       {
4969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4970       };
4971     }
4972   }
4973
4974   jresult = (void *)result;
4975   return jresult;
4976 }
4977
4978
4979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4980   void * jresult ;
4981   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4982   Dali::Vector2 result;
4983
4984   arg1 = (Dali::Vector2 *)jarg1;
4985   {
4986     try {
4987       result = ((Dali::Vector2 const *)arg1)->operator -();
4988     } catch (std::out_of_range& e) {
4989       {
4990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4991       };
4992     } catch (std::exception& e) {
4993       {
4994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4995       };
4996     } catch (Dali::DaliException e) {
4997       {
4998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4999       };
5000     } catch (...) {
5001       {
5002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5003       };
5004     }
5005   }
5006
5007   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5008   return jresult;
5009 }
5010
5011
5012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5013   unsigned int jresult ;
5014   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5015   Dali::Vector2 *arg2 = 0 ;
5016   bool result;
5017
5018   arg1 = (Dali::Vector2 *)jarg1;
5019   arg2 = (Dali::Vector2 *)jarg2;
5020   if (!arg2) {
5021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5022     return 0;
5023   }
5024   {
5025     try {
5026       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5027     } catch (std::out_of_range& e) {
5028       {
5029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5030       };
5031     } catch (std::exception& e) {
5032       {
5033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5034       };
5035     } catch (Dali::DaliException e) {
5036       {
5037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5038       };
5039     } catch (...) {
5040       {
5041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5042       };
5043     }
5044   }
5045
5046   jresult = result;
5047   return jresult;
5048 }
5049
5050
5051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5052   unsigned int jresult ;
5053   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5054   Dali::Vector2 *arg2 = 0 ;
5055   bool result;
5056
5057   arg1 = (Dali::Vector2 *)jarg1;
5058   arg2 = (Dali::Vector2 *)jarg2;
5059   if (!arg2) {
5060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5061     return 0;
5062   }
5063   {
5064     try {
5065       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5066     } catch (std::out_of_range& e) {
5067       {
5068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5069       };
5070     } catch (std::exception& e) {
5071       {
5072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5073       };
5074     } catch (Dali::DaliException e) {
5075       {
5076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5077       };
5078     } catch (...) {
5079       {
5080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5081       };
5082     }
5083   }
5084
5085   jresult = result;
5086   return jresult;
5087 }
5088
5089
5090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5091   float jresult ;
5092   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5093   unsigned int arg2 ;
5094   float *result = 0 ;
5095
5096   arg1 = (Dali::Vector2 *)jarg1;
5097   arg2 = (unsigned int)jarg2;
5098   {
5099     try {
5100       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5101     } catch (std::out_of_range& e) {
5102       {
5103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5104       };
5105     } catch (std::exception& e) {
5106       {
5107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5108       };
5109     } catch (Dali::DaliException e) {
5110       {
5111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5112       };
5113     } catch (...) {
5114       {
5115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5116       };
5117     }
5118   }
5119
5120   jresult = *result;
5121   return jresult;
5122 }
5123
5124
5125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5126   float jresult ;
5127   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5128   float result;
5129
5130   arg1 = (Dali::Vector2 *)jarg1;
5131   {
5132     try {
5133       result = (float)((Dali::Vector2 const *)arg1)->Length();
5134     } catch (std::out_of_range& e) {
5135       {
5136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5137       };
5138     } catch (std::exception& e) {
5139       {
5140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5141       };
5142     } catch (Dali::DaliException e) {
5143       {
5144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5145       };
5146     } catch (...) {
5147       {
5148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5149       };
5150     }
5151   }
5152
5153   jresult = result;
5154   return jresult;
5155 }
5156
5157
5158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5159   float jresult ;
5160   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5161   float result;
5162
5163   arg1 = (Dali::Vector2 *)jarg1;
5164   {
5165     try {
5166       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5167     } catch (std::out_of_range& e) {
5168       {
5169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5170       };
5171     } catch (std::exception& e) {
5172       {
5173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5174       };
5175     } catch (Dali::DaliException e) {
5176       {
5177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5178       };
5179     } catch (...) {
5180       {
5181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5182       };
5183     }
5184   }
5185
5186   jresult = result;
5187   return jresult;
5188 }
5189
5190
5191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5192   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5193
5194   arg1 = (Dali::Vector2 *)jarg1;
5195   {
5196     try {
5197       (arg1)->Normalize();
5198     } catch (std::out_of_range& e) {
5199       {
5200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5201       };
5202     } catch (std::exception& e) {
5203       {
5204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5205       };
5206     } catch (Dali::DaliException e) {
5207       {
5208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5209       };
5210     } catch (...) {
5211       {
5212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5213       };
5214     }
5215   }
5216
5217 }
5218
5219
5220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5221   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5222   Dali::Vector2 *arg2 = 0 ;
5223   Dali::Vector2 *arg3 = 0 ;
5224
5225   arg1 = (Dali::Vector2 *)jarg1;
5226   arg2 = (Dali::Vector2 *)jarg2;
5227   if (!arg2) {
5228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5229     return ;
5230   }
5231   arg3 = (Dali::Vector2 *)jarg3;
5232   if (!arg3) {
5233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5234     return ;
5235   }
5236   {
5237     try {
5238       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5239     } catch (std::out_of_range& e) {
5240       {
5241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5242       };
5243     } catch (std::exception& e) {
5244       {
5245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5246       };
5247     } catch (Dali::DaliException e) {
5248       {
5249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5250       };
5251     } catch (...) {
5252       {
5253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5254       };
5255     }
5256   }
5257
5258 }
5259
5260
5261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5262   void * jresult ;
5263   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5264   float *result = 0 ;
5265
5266   arg1 = (Dali::Vector2 *)jarg1;
5267   {
5268     try {
5269       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5270     } catch (std::out_of_range& e) {
5271       {
5272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5273       };
5274     } catch (std::exception& e) {
5275       {
5276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5277       };
5278     } catch (Dali::DaliException e) {
5279       {
5280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5281       };
5282     } catch (...) {
5283       {
5284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5285       };
5286     }
5287   }
5288
5289   jresult = (void *)result;
5290   return jresult;
5291 }
5292
5293
5294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5295   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5296   float arg2 ;
5297
5298   arg1 = (Dali::Vector2 *)jarg1;
5299   arg2 = (float)jarg2;
5300   if (arg1) (arg1)->x = arg2;
5301 }
5302
5303
5304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5305   float jresult ;
5306   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5307   float result;
5308
5309   arg1 = (Dali::Vector2 *)jarg1;
5310   result = (float) ((arg1)->x);
5311   jresult = result;
5312   return jresult;
5313 }
5314
5315
5316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5317   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5318   float arg2 ;
5319
5320   arg1 = (Dali::Vector2 *)jarg1;
5321   arg2 = (float)jarg2;
5322   if (arg1) (arg1)->width = arg2;
5323 }
5324
5325
5326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5327   float jresult ;
5328   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5329   float result;
5330
5331   arg1 = (Dali::Vector2 *)jarg1;
5332   result = (float) ((arg1)->width);
5333   jresult = result;
5334   return jresult;
5335 }
5336
5337
5338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5339   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5340   float arg2 ;
5341
5342   arg1 = (Dali::Vector2 *)jarg1;
5343   arg2 = (float)jarg2;
5344   if (arg1) (arg1)->y = arg2;
5345 }
5346
5347
5348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5349   float jresult ;
5350   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5351   float result;
5352
5353   arg1 = (Dali::Vector2 *)jarg1;
5354   result = (float) ((arg1)->y);
5355   jresult = result;
5356   return jresult;
5357 }
5358
5359
5360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5361   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5362   float arg2 ;
5363
5364   arg1 = (Dali::Vector2 *)jarg1;
5365   arg2 = (float)jarg2;
5366   if (arg1) (arg1)->height = arg2;
5367 }
5368
5369
5370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5371   float jresult ;
5372   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5373   float result;
5374
5375   arg1 = (Dali::Vector2 *)jarg1;
5376   result = (float) ((arg1)->height);
5377   jresult = result;
5378   return jresult;
5379 }
5380
5381
5382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5383   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5384
5385   arg1 = (Dali::Vector2 *)jarg1;
5386   {
5387     try {
5388       delete arg1;
5389     } catch (std::out_of_range& e) {
5390       {
5391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5392       };
5393     } catch (std::exception& e) {
5394       {
5395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5396       };
5397     } catch (Dali::DaliException e) {
5398       {
5399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5400       };
5401     } catch (...) {
5402       {
5403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5404       };
5405     }
5406   }
5407
5408 }
5409
5410
5411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5412   void * jresult ;
5413   Dali::Vector2 *arg1 = 0 ;
5414   Dali::Vector2 *arg2 = 0 ;
5415   Dali::Vector2 result;
5416
5417   arg1 = (Dali::Vector2 *)jarg1;
5418   if (!arg1) {
5419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5420     return 0;
5421   }
5422   arg2 = (Dali::Vector2 *)jarg2;
5423   if (!arg2) {
5424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5425     return 0;
5426   }
5427   {
5428     try {
5429       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5430     } catch (std::out_of_range& e) {
5431       {
5432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5433       };
5434     } catch (std::exception& e) {
5435       {
5436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5437       };
5438     } catch (Dali::DaliException e) {
5439       {
5440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5441       };
5442     } catch (...) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5445       };
5446     }
5447   }
5448
5449   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5450   return jresult;
5451 }
5452
5453
5454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5455   void * jresult ;
5456   Dali::Vector2 *arg1 = 0 ;
5457   Dali::Vector2 *arg2 = 0 ;
5458   Dali::Vector2 result;
5459
5460   arg1 = (Dali::Vector2 *)jarg1;
5461   if (!arg1) {
5462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5463     return 0;
5464   }
5465   arg2 = (Dali::Vector2 *)jarg2;
5466   if (!arg2) {
5467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5468     return 0;
5469   }
5470   {
5471     try {
5472       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5473     } catch (std::out_of_range& e) {
5474       {
5475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5476       };
5477     } catch (std::exception& e) {
5478       {
5479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5480       };
5481     } catch (Dali::DaliException e) {
5482       {
5483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5484       };
5485     } catch (...) {
5486       {
5487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5488       };
5489     }
5490   }
5491
5492   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5493   return jresult;
5494 }
5495
5496
5497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5498   void * jresult ;
5499   Dali::Vector2 *arg1 = 0 ;
5500   float *arg2 = 0 ;
5501   float *arg3 = 0 ;
5502   float temp2 ;
5503   float temp3 ;
5504   Dali::Vector2 result;
5505
5506   arg1 = (Dali::Vector2 *)jarg1;
5507   if (!arg1) {
5508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5509     return 0;
5510   }
5511   temp2 = (float)jarg2;
5512   arg2 = &temp2;
5513   temp3 = (float)jarg3;
5514   arg3 = &temp3;
5515   {
5516     try {
5517       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5518     } catch (std::out_of_range& e) {
5519       {
5520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5521       };
5522     } catch (std::exception& e) {
5523       {
5524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5525       };
5526     } catch (Dali::DaliException e) {
5527       {
5528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5529       };
5530     } catch (...) {
5531       {
5532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5533       };
5534     }
5535   }
5536
5537   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5538   return jresult;
5539 }
5540
5541
5542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5543   void * jresult ;
5544   Dali::Vector3 *result = 0 ;
5545
5546   {
5547     try {
5548       result = (Dali::Vector3 *)new Dali::Vector3();
5549     } catch (std::out_of_range& e) {
5550       {
5551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5552       };
5553     } catch (std::exception& e) {
5554       {
5555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5556       };
5557     } catch (Dali::DaliException e) {
5558       {
5559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5560       };
5561     } catch (...) {
5562       {
5563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5564       };
5565     }
5566   }
5567
5568   jresult = (void *)result;
5569   return jresult;
5570 }
5571
5572
5573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5574   void * jresult ;
5575   float arg1 ;
5576   float arg2 ;
5577   float arg3 ;
5578   Dali::Vector3 *result = 0 ;
5579
5580   arg1 = (float)jarg1;
5581   arg2 = (float)jarg2;
5582   arg3 = (float)jarg3;
5583   {
5584     try {
5585       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5586     } catch (std::out_of_range& e) {
5587       {
5588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5589       };
5590     } catch (std::exception& e) {
5591       {
5592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5593       };
5594     } catch (Dali::DaliException e) {
5595       {
5596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5597       };
5598     } catch (...) {
5599       {
5600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5601       };
5602     }
5603   }
5604
5605   jresult = (void *)result;
5606   return jresult;
5607 }
5608
5609
5610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5611   void * jresult ;
5612   float *arg1 = (float *) 0 ;
5613   Dali::Vector3 *result = 0 ;
5614
5615   arg1 = jarg1;
5616   {
5617     try {
5618       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5619     } catch (std::out_of_range& e) {
5620       {
5621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5622       };
5623     } catch (std::exception& e) {
5624       {
5625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5626       };
5627     } catch (Dali::DaliException e) {
5628       {
5629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5630       };
5631     } catch (...) {
5632       {
5633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5634       };
5635     }
5636   }
5637
5638   jresult = (void *)result;
5639
5640
5641   return jresult;
5642 }
5643
5644
5645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5646   void * jresult ;
5647   Dali::Vector2 *arg1 = 0 ;
5648   Dali::Vector3 *result = 0 ;
5649
5650   arg1 = (Dali::Vector2 *)jarg1;
5651   if (!arg1) {
5652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5653     return 0;
5654   }
5655   {
5656     try {
5657       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5658     } catch (std::out_of_range& e) {
5659       {
5660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5661       };
5662     } catch (std::exception& e) {
5663       {
5664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5665       };
5666     } catch (Dali::DaliException e) {
5667       {
5668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5669       };
5670     } catch (...) {
5671       {
5672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5673       };
5674     }
5675   }
5676
5677   jresult = (void *)result;
5678   return jresult;
5679 }
5680
5681
5682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5683   void * jresult ;
5684   Dali::Vector4 *arg1 = 0 ;
5685   Dali::Vector3 *result = 0 ;
5686
5687   arg1 = (Dali::Vector4 *)jarg1;
5688   if (!arg1) {
5689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5690     return 0;
5691   }
5692   {
5693     try {
5694       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5695     } catch (std::out_of_range& e) {
5696       {
5697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5698       };
5699     } catch (std::exception& e) {
5700       {
5701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5702       };
5703     } catch (Dali::DaliException e) {
5704       {
5705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5706       };
5707     } catch (...) {
5708       {
5709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5710       };
5711     }
5712   }
5713
5714   jresult = (void *)result;
5715   return jresult;
5716 }
5717
5718
5719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5720   void * jresult ;
5721   Dali::Vector3 *result = 0 ;
5722
5723   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5724   jresult = (void *)result;
5725   return jresult;
5726 }
5727
5728
5729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5730   void * jresult ;
5731   Dali::Vector3 *result = 0 ;
5732
5733   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5734   jresult = (void *)result;
5735   return jresult;
5736 }
5737
5738
5739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5740   void * jresult ;
5741   Dali::Vector3 *result = 0 ;
5742
5743   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5744   jresult = (void *)result;
5745   return jresult;
5746 }
5747
5748
5749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5750   void * jresult ;
5751   Dali::Vector3 *result = 0 ;
5752
5753   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5754   jresult = (void *)result;
5755   return jresult;
5756 }
5757
5758
5759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5760   void * jresult ;
5761   Dali::Vector3 *result = 0 ;
5762
5763   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5764   jresult = (void *)result;
5765   return jresult;
5766 }
5767
5768
5769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5770   void * jresult ;
5771   Dali::Vector3 *result = 0 ;
5772
5773   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5774   jresult = (void *)result;
5775   return jresult;
5776 }
5777
5778
5779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5780   void * jresult ;
5781   Dali::Vector3 *result = 0 ;
5782
5783   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5784   jresult = (void *)result;
5785   return jresult;
5786 }
5787
5788
5789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5790   void * jresult ;
5791   Dali::Vector3 *result = 0 ;
5792
5793   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5794   jresult = (void *)result;
5795   return jresult;
5796 }
5797
5798
5799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5800   void * jresult ;
5801   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5802   float *arg2 = (float *) 0 ;
5803   Dali::Vector3 *result = 0 ;
5804
5805   arg1 = (Dali::Vector3 *)jarg1;
5806   arg2 = jarg2;
5807   {
5808     try {
5809       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5810     } catch (std::out_of_range& e) {
5811       {
5812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5813       };
5814     } catch (std::exception& e) {
5815       {
5816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5817       };
5818     } catch (Dali::DaliException e) {
5819       {
5820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5821       };
5822     } catch (...) {
5823       {
5824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5825       };
5826     }
5827   }
5828
5829   jresult = (void *)result;
5830
5831
5832   return jresult;
5833 }
5834
5835
5836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5837   void * jresult ;
5838   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5839   Dali::Vector2 *arg2 = 0 ;
5840   Dali::Vector3 *result = 0 ;
5841
5842   arg1 = (Dali::Vector3 *)jarg1;
5843   arg2 = (Dali::Vector2 *)jarg2;
5844   if (!arg2) {
5845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5846     return 0;
5847   }
5848   {
5849     try {
5850       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5851     } catch (std::out_of_range& e) {
5852       {
5853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5854       };
5855     } catch (std::exception& e) {
5856       {
5857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5858       };
5859     } catch (Dali::DaliException e) {
5860       {
5861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5862       };
5863     } catch (...) {
5864       {
5865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5866       };
5867     }
5868   }
5869
5870   jresult = (void *)result;
5871   return jresult;
5872 }
5873
5874
5875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5876   void * jresult ;
5877   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5878   Dali::Vector4 *arg2 = 0 ;
5879   Dali::Vector3 *result = 0 ;
5880
5881   arg1 = (Dali::Vector3 *)jarg1;
5882   arg2 = (Dali::Vector4 *)jarg2;
5883   if (!arg2) {
5884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5885     return 0;
5886   }
5887   {
5888     try {
5889       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5890     } catch (std::out_of_range& e) {
5891       {
5892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5893       };
5894     } catch (std::exception& e) {
5895       {
5896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5897       };
5898     } catch (Dali::DaliException e) {
5899       {
5900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5901       };
5902     } catch (...) {
5903       {
5904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5905       };
5906     }
5907   }
5908
5909   jresult = (void *)result;
5910   return jresult;
5911 }
5912
5913
5914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5915   void * jresult ;
5916   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5917   Dali::Vector3 *arg2 = 0 ;
5918   Dali::Vector3 result;
5919
5920   arg1 = (Dali::Vector3 *)jarg1;
5921   arg2 = (Dali::Vector3 *)jarg2;
5922   if (!arg2) {
5923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5924     return 0;
5925   }
5926   {
5927     try {
5928       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5929     } catch (std::out_of_range& e) {
5930       {
5931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5932       };
5933     } catch (std::exception& e) {
5934       {
5935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5936       };
5937     } catch (Dali::DaliException e) {
5938       {
5939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5940       };
5941     } catch (...) {
5942       {
5943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5944       };
5945     }
5946   }
5947
5948   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5949   return jresult;
5950 }
5951
5952
5953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5954   void * jresult ;
5955   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5956   Dali::Vector3 *arg2 = 0 ;
5957   Dali::Vector3 *result = 0 ;
5958
5959   arg1 = (Dali::Vector3 *)jarg1;
5960   arg2 = (Dali::Vector3 *)jarg2;
5961   if (!arg2) {
5962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5963     return 0;
5964   }
5965   {
5966     try {
5967       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5968     } catch (std::out_of_range& e) {
5969       {
5970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5971       };
5972     } catch (std::exception& e) {
5973       {
5974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5975       };
5976     } catch (Dali::DaliException e) {
5977       {
5978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5979       };
5980     } catch (...) {
5981       {
5982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5983       };
5984     }
5985   }
5986
5987   jresult = (void *)result;
5988   return jresult;
5989 }
5990
5991
5992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5993   void * jresult ;
5994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5995   Dali::Vector3 *arg2 = 0 ;
5996   Dali::Vector3 result;
5997
5998   arg1 = (Dali::Vector3 *)jarg1;
5999   arg2 = (Dali::Vector3 *)jarg2;
6000   if (!arg2) {
6001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6002     return 0;
6003   }
6004   {
6005     try {
6006       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6007     } catch (std::out_of_range& e) {
6008       {
6009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6010       };
6011     } catch (std::exception& e) {
6012       {
6013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6014       };
6015     } catch (Dali::DaliException e) {
6016       {
6017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6018       };
6019     } catch (...) {
6020       {
6021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6022       };
6023     }
6024   }
6025
6026   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6027   return jresult;
6028 }
6029
6030
6031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6032   void * jresult ;
6033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6034   Dali::Vector3 *arg2 = 0 ;
6035   Dali::Vector3 *result = 0 ;
6036
6037   arg1 = (Dali::Vector3 *)jarg1;
6038   arg2 = (Dali::Vector3 *)jarg2;
6039   if (!arg2) {
6040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6041     return 0;
6042   }
6043   {
6044     try {
6045       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6046     } catch (std::out_of_range& e) {
6047       {
6048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6049       };
6050     } catch (std::exception& e) {
6051       {
6052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6053       };
6054     } catch (Dali::DaliException e) {
6055       {
6056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6057       };
6058     } catch (...) {
6059       {
6060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6061       };
6062     }
6063   }
6064
6065   jresult = (void *)result;
6066   return jresult;
6067 }
6068
6069
6070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6071   void * jresult ;
6072   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6073   Dali::Vector3 *arg2 = 0 ;
6074   Dali::Vector3 result;
6075
6076   arg1 = (Dali::Vector3 *)jarg1;
6077   arg2 = (Dali::Vector3 *)jarg2;
6078   if (!arg2) {
6079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6080     return 0;
6081   }
6082   {
6083     try {
6084       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6085     } catch (std::out_of_range& e) {
6086       {
6087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6088       };
6089     } catch (std::exception& e) {
6090       {
6091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6092       };
6093     } catch (Dali::DaliException e) {
6094       {
6095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6096       };
6097     } catch (...) {
6098       {
6099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6100       };
6101     }
6102   }
6103
6104   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6105   return jresult;
6106 }
6107
6108
6109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6110   void * jresult ;
6111   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6112   float arg2 ;
6113   Dali::Vector3 result;
6114
6115   arg1 = (Dali::Vector3 *)jarg1;
6116   arg2 = (float)jarg2;
6117   {
6118     try {
6119       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6120     } catch (std::out_of_range& e) {
6121       {
6122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6123       };
6124     } catch (std::exception& e) {
6125       {
6126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6127       };
6128     } catch (Dali::DaliException e) {
6129       {
6130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6131       };
6132     } catch (...) {
6133       {
6134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6135       };
6136     }
6137   }
6138
6139   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6140   return jresult;
6141 }
6142
6143
6144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6145   void * jresult ;
6146   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6147   Dali::Vector3 *arg2 = 0 ;
6148   Dali::Vector3 *result = 0 ;
6149
6150   arg1 = (Dali::Vector3 *)jarg1;
6151   arg2 = (Dali::Vector3 *)jarg2;
6152   if (!arg2) {
6153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6154     return 0;
6155   }
6156   {
6157     try {
6158       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6159     } catch (std::out_of_range& e) {
6160       {
6161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6162       };
6163     } catch (std::exception& e) {
6164       {
6165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6166       };
6167     } catch (Dali::DaliException e) {
6168       {
6169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6170       };
6171     } catch (...) {
6172       {
6173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6174       };
6175     }
6176   }
6177
6178   jresult = (void *)result;
6179   return jresult;
6180 }
6181
6182
6183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6184   void * jresult ;
6185   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6186   float arg2 ;
6187   Dali::Vector3 *result = 0 ;
6188
6189   arg1 = (Dali::Vector3 *)jarg1;
6190   arg2 = (float)jarg2;
6191   {
6192     try {
6193       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6194     } catch (std::out_of_range& e) {
6195       {
6196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6197       };
6198     } catch (std::exception& e) {
6199       {
6200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6201       };
6202     } catch (Dali::DaliException e) {
6203       {
6204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6205       };
6206     } catch (...) {
6207       {
6208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6209       };
6210     }
6211   }
6212
6213   jresult = (void *)result;
6214   return jresult;
6215 }
6216
6217
6218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6219   void * jresult ;
6220   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6221   Dali::Quaternion *arg2 = 0 ;
6222   Dali::Vector3 *result = 0 ;
6223
6224   arg1 = (Dali::Vector3 *)jarg1;
6225   arg2 = (Dali::Quaternion *)jarg2;
6226   if (!arg2) {
6227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6228     return 0;
6229   }
6230   {
6231     try {
6232       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6233     } catch (std::out_of_range& e) {
6234       {
6235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6236       };
6237     } catch (std::exception& e) {
6238       {
6239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6240       };
6241     } catch (Dali::DaliException e) {
6242       {
6243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6244       };
6245     } catch (...) {
6246       {
6247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6248       };
6249     }
6250   }
6251
6252   jresult = (void *)result;
6253   return jresult;
6254 }
6255
6256
6257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6258   void * jresult ;
6259   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6260   Dali::Vector3 *arg2 = 0 ;
6261   Dali::Vector3 result;
6262
6263   arg1 = (Dali::Vector3 *)jarg1;
6264   arg2 = (Dali::Vector3 *)jarg2;
6265   if (!arg2) {
6266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6267     return 0;
6268   }
6269   {
6270     try {
6271       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6272     } catch (std::out_of_range& e) {
6273       {
6274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6275       };
6276     } catch (std::exception& e) {
6277       {
6278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6279       };
6280     } catch (Dali::DaliException e) {
6281       {
6282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6283       };
6284     } catch (...) {
6285       {
6286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6287       };
6288     }
6289   }
6290
6291   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6292   return jresult;
6293 }
6294
6295
6296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6297   void * jresult ;
6298   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6299   float arg2 ;
6300   Dali::Vector3 result;
6301
6302   arg1 = (Dali::Vector3 *)jarg1;
6303   arg2 = (float)jarg2;
6304   {
6305     try {
6306       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6307     } catch (std::out_of_range& e) {
6308       {
6309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6310       };
6311     } catch (std::exception& e) {
6312       {
6313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6314       };
6315     } catch (Dali::DaliException e) {
6316       {
6317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6318       };
6319     } catch (...) {
6320       {
6321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6322       };
6323     }
6324   }
6325
6326   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6327   return jresult;
6328 }
6329
6330
6331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6332   void * jresult ;
6333   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6334   Dali::Vector3 *arg2 = 0 ;
6335   Dali::Vector3 *result = 0 ;
6336
6337   arg1 = (Dali::Vector3 *)jarg1;
6338   arg2 = (Dali::Vector3 *)jarg2;
6339   if (!arg2) {
6340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6341     return 0;
6342   }
6343   {
6344     try {
6345       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6346     } catch (std::out_of_range& e) {
6347       {
6348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6349       };
6350     } catch (std::exception& e) {
6351       {
6352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6353       };
6354     } catch (Dali::DaliException e) {
6355       {
6356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6357       };
6358     } catch (...) {
6359       {
6360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6361       };
6362     }
6363   }
6364
6365   jresult = (void *)result;
6366   return jresult;
6367 }
6368
6369
6370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6371   void * jresult ;
6372   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6373   float arg2 ;
6374   Dali::Vector3 *result = 0 ;
6375
6376   arg1 = (Dali::Vector3 *)jarg1;
6377   arg2 = (float)jarg2;
6378   {
6379     try {
6380       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6381     } catch (std::out_of_range& e) {
6382       {
6383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6384       };
6385     } catch (std::exception& e) {
6386       {
6387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6388       };
6389     } catch (Dali::DaliException e) {
6390       {
6391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6392       };
6393     } catch (...) {
6394       {
6395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6396       };
6397     }
6398   }
6399
6400   jresult = (void *)result;
6401   return jresult;
6402 }
6403
6404
6405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6406   void * jresult ;
6407   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6408   Dali::Vector3 result;
6409
6410   arg1 = (Dali::Vector3 *)jarg1;
6411   {
6412     try {
6413       result = ((Dali::Vector3 const *)arg1)->operator -();
6414     } catch (std::out_of_range& e) {
6415       {
6416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6417       };
6418     } catch (std::exception& e) {
6419       {
6420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6421       };
6422     } catch (Dali::DaliException e) {
6423       {
6424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6425       };
6426     } catch (...) {
6427       {
6428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6429       };
6430     }
6431   }
6432
6433   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6434   return jresult;
6435 }
6436
6437
6438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6439   unsigned int jresult ;
6440   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6441   Dali::Vector3 *arg2 = 0 ;
6442   bool result;
6443
6444   arg1 = (Dali::Vector3 *)jarg1;
6445   arg2 = (Dali::Vector3 *)jarg2;
6446   if (!arg2) {
6447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6448     return 0;
6449   }
6450   {
6451     try {
6452       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6453     } catch (std::out_of_range& e) {
6454       {
6455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6456       };
6457     } catch (std::exception& e) {
6458       {
6459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6460       };
6461     } catch (Dali::DaliException e) {
6462       {
6463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6464       };
6465     } catch (...) {
6466       {
6467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6468       };
6469     }
6470   }
6471
6472   jresult = result;
6473   return jresult;
6474 }
6475
6476
6477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6478   unsigned int jresult ;
6479   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6480   Dali::Vector3 *arg2 = 0 ;
6481   bool result;
6482
6483   arg1 = (Dali::Vector3 *)jarg1;
6484   arg2 = (Dali::Vector3 *)jarg2;
6485   if (!arg2) {
6486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6487     return 0;
6488   }
6489   {
6490     try {
6491       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6492     } catch (std::out_of_range& e) {
6493       {
6494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6495       };
6496     } catch (std::exception& e) {
6497       {
6498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6499       };
6500     } catch (Dali::DaliException e) {
6501       {
6502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6503       };
6504     } catch (...) {
6505       {
6506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6507       };
6508     }
6509   }
6510
6511   jresult = result;
6512   return jresult;
6513 }
6514
6515
6516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6517   float jresult ;
6518   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6519   unsigned int arg2 ;
6520   float *result = 0 ;
6521
6522   arg1 = (Dali::Vector3 *)jarg1;
6523   arg2 = (unsigned int)jarg2;
6524   {
6525     try {
6526       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6527     } catch (std::out_of_range& e) {
6528       {
6529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6530       };
6531     } catch (std::exception& e) {
6532       {
6533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6534       };
6535     } catch (Dali::DaliException e) {
6536       {
6537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6538       };
6539     } catch (...) {
6540       {
6541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6542       };
6543     }
6544   }
6545
6546   jresult = *result;
6547   return jresult;
6548 }
6549
6550
6551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6552   float jresult ;
6553   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6554   Dali::Vector3 *arg2 = 0 ;
6555   float result;
6556
6557   arg1 = (Dali::Vector3 *)jarg1;
6558   arg2 = (Dali::Vector3 *)jarg2;
6559   if (!arg2) {
6560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6561     return 0;
6562   }
6563   {
6564     try {
6565       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6566     } catch (std::out_of_range& e) {
6567       {
6568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6569       };
6570     } catch (std::exception& e) {
6571       {
6572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6573       };
6574     } catch (Dali::DaliException e) {
6575       {
6576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6577       };
6578     } catch (...) {
6579       {
6580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6581       };
6582     }
6583   }
6584
6585   jresult = result;
6586   return jresult;
6587 }
6588
6589
6590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6591   void * jresult ;
6592   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6593   Dali::Vector3 *arg2 = 0 ;
6594   Dali::Vector3 result;
6595
6596   arg1 = (Dali::Vector3 *)jarg1;
6597   arg2 = (Dali::Vector3 *)jarg2;
6598   if (!arg2) {
6599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6600     return 0;
6601   }
6602   {
6603     try {
6604       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6605     } catch (std::out_of_range& e) {
6606       {
6607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6608       };
6609     } catch (std::exception& e) {
6610       {
6611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6612       };
6613     } catch (Dali::DaliException e) {
6614       {
6615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6616       };
6617     } catch (...) {
6618       {
6619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6620       };
6621     }
6622   }
6623
6624   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6625   return jresult;
6626 }
6627
6628
6629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6630   float jresult ;
6631   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6632   float result;
6633
6634   arg1 = (Dali::Vector3 *)jarg1;
6635   {
6636     try {
6637       result = (float)((Dali::Vector3 const *)arg1)->Length();
6638     } catch (std::out_of_range& e) {
6639       {
6640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6641       };
6642     } catch (std::exception& e) {
6643       {
6644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6645       };
6646     } catch (Dali::DaliException e) {
6647       {
6648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6649       };
6650     } catch (...) {
6651       {
6652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6653       };
6654     }
6655   }
6656
6657   jresult = result;
6658   return jresult;
6659 }
6660
6661
6662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6663   float jresult ;
6664   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6665   float result;
6666
6667   arg1 = (Dali::Vector3 *)jarg1;
6668   {
6669     try {
6670       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6671     } catch (std::out_of_range& e) {
6672       {
6673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6674       };
6675     } catch (std::exception& e) {
6676       {
6677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6678       };
6679     } catch (Dali::DaliException e) {
6680       {
6681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6682       };
6683     } catch (...) {
6684       {
6685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6686       };
6687     }
6688   }
6689
6690   jresult = result;
6691   return jresult;
6692 }
6693
6694
6695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6696   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6697
6698   arg1 = (Dali::Vector3 *)jarg1;
6699   {
6700     try {
6701       (arg1)->Normalize();
6702     } catch (std::out_of_range& e) {
6703       {
6704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6705       };
6706     } catch (std::exception& e) {
6707       {
6708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6709       };
6710     } catch (Dali::DaliException e) {
6711       {
6712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6713       };
6714     } catch (...) {
6715       {
6716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6717       };
6718     }
6719   }
6720
6721 }
6722
6723
6724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6725   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6726   Dali::Vector3 *arg2 = 0 ;
6727   Dali::Vector3 *arg3 = 0 ;
6728
6729   arg1 = (Dali::Vector3 *)jarg1;
6730   arg2 = (Dali::Vector3 *)jarg2;
6731   if (!arg2) {
6732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6733     return ;
6734   }
6735   arg3 = (Dali::Vector3 *)jarg3;
6736   if (!arg3) {
6737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6738     return ;
6739   }
6740   {
6741     try {
6742       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6743     } catch (std::out_of_range& e) {
6744       {
6745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6746       };
6747     } catch (std::exception& e) {
6748       {
6749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6750       };
6751     } catch (Dali::DaliException e) {
6752       {
6753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6754       };
6755     } catch (...) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6758       };
6759     }
6760   }
6761
6762 }
6763
6764
6765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6766   void * jresult ;
6767   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6768   float *result = 0 ;
6769
6770   arg1 = (Dali::Vector3 *)jarg1;
6771   {
6772     try {
6773       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6774     } catch (std::out_of_range& e) {
6775       {
6776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6777       };
6778     } catch (std::exception& e) {
6779       {
6780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6781       };
6782     } catch (Dali::DaliException e) {
6783       {
6784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6785       };
6786     } catch (...) {
6787       {
6788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6789       };
6790     }
6791   }
6792
6793   jresult = (void *)result;
6794   return jresult;
6795 }
6796
6797
6798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6799   void * jresult ;
6800   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6801   Dali::Vector2 *result = 0 ;
6802
6803   arg1 = (Dali::Vector3 *)jarg1;
6804   {
6805     try {
6806       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6807     } catch (std::out_of_range& e) {
6808       {
6809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6810       };
6811     } catch (std::exception& e) {
6812       {
6813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6814       };
6815     } catch (Dali::DaliException e) {
6816       {
6817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6818       };
6819     } catch (...) {
6820       {
6821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6822       };
6823     }
6824   }
6825
6826   jresult = (void *)result;
6827   return jresult;
6828 }
6829
6830
6831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6832   void * jresult ;
6833   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6834   Dali::Vector2 *result = 0 ;
6835
6836   arg1 = (Dali::Vector3 *)jarg1;
6837   {
6838     try {
6839       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6840     } catch (std::out_of_range& e) {
6841       {
6842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6843       };
6844     } catch (std::exception& e) {
6845       {
6846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6847       };
6848     } catch (Dali::DaliException e) {
6849       {
6850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6851       };
6852     } catch (...) {
6853       {
6854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6855       };
6856     }
6857   }
6858
6859   jresult = (void *)result;
6860   return jresult;
6861 }
6862
6863
6864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6865   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6866   float arg2 ;
6867
6868   arg1 = (Dali::Vector3 *)jarg1;
6869   arg2 = (float)jarg2;
6870   if (arg1) (arg1)->x = arg2;
6871 }
6872
6873
6874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6875   float jresult ;
6876   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6877   float result;
6878
6879   arg1 = (Dali::Vector3 *)jarg1;
6880   result = (float) ((arg1)->x);
6881   jresult = result;
6882   return jresult;
6883 }
6884
6885
6886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6887   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6888   float arg2 ;
6889
6890   arg1 = (Dali::Vector3 *)jarg1;
6891   arg2 = (float)jarg2;
6892   if (arg1) (arg1)->width = arg2;
6893 }
6894
6895
6896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6897   float jresult ;
6898   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6899   float result;
6900
6901   arg1 = (Dali::Vector3 *)jarg1;
6902   result = (float) ((arg1)->width);
6903   jresult = result;
6904   return jresult;
6905 }
6906
6907
6908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6909   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6910   float arg2 ;
6911
6912   arg1 = (Dali::Vector3 *)jarg1;
6913   arg2 = (float)jarg2;
6914   if (arg1) (arg1)->r = arg2;
6915 }
6916
6917
6918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6919   float jresult ;
6920   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6921   float result;
6922
6923   arg1 = (Dali::Vector3 *)jarg1;
6924   result = (float) ((arg1)->r);
6925   jresult = result;
6926   return jresult;
6927 }
6928
6929
6930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6931   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6932   float arg2 ;
6933
6934   arg1 = (Dali::Vector3 *)jarg1;
6935   arg2 = (float)jarg2;
6936   if (arg1) (arg1)->y = arg2;
6937 }
6938
6939
6940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6941   float jresult ;
6942   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6943   float result;
6944
6945   arg1 = (Dali::Vector3 *)jarg1;
6946   result = (float) ((arg1)->y);
6947   jresult = result;
6948   return jresult;
6949 }
6950
6951
6952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6953   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6954   float arg2 ;
6955
6956   arg1 = (Dali::Vector3 *)jarg1;
6957   arg2 = (float)jarg2;
6958   if (arg1) (arg1)->height = arg2;
6959 }
6960
6961
6962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6963   float jresult ;
6964   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6965   float result;
6966
6967   arg1 = (Dali::Vector3 *)jarg1;
6968   result = (float) ((arg1)->height);
6969   jresult = result;
6970   return jresult;
6971 }
6972
6973
6974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6975   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6976   float arg2 ;
6977
6978   arg1 = (Dali::Vector3 *)jarg1;
6979   arg2 = (float)jarg2;
6980   if (arg1) (arg1)->g = arg2;
6981 }
6982
6983
6984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6985   float jresult ;
6986   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6987   float result;
6988
6989   arg1 = (Dali::Vector3 *)jarg1;
6990   result = (float) ((arg1)->g);
6991   jresult = result;
6992   return jresult;
6993 }
6994
6995
6996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6997   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6998   float arg2 ;
6999
7000   arg1 = (Dali::Vector3 *)jarg1;
7001   arg2 = (float)jarg2;
7002   if (arg1) (arg1)->z = arg2;
7003 }
7004
7005
7006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7007   float jresult ;
7008   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7009   float result;
7010
7011   arg1 = (Dali::Vector3 *)jarg1;
7012   result = (float) ((arg1)->z);
7013   jresult = result;
7014   return jresult;
7015 }
7016
7017
7018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7019   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7020   float arg2 ;
7021
7022   arg1 = (Dali::Vector3 *)jarg1;
7023   arg2 = (float)jarg2;
7024   if (arg1) (arg1)->depth = arg2;
7025 }
7026
7027
7028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7029   float jresult ;
7030   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7031   float result;
7032
7033   arg1 = (Dali::Vector3 *)jarg1;
7034   result = (float) ((arg1)->depth);
7035   jresult = result;
7036   return jresult;
7037 }
7038
7039
7040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7042   float arg2 ;
7043
7044   arg1 = (Dali::Vector3 *)jarg1;
7045   arg2 = (float)jarg2;
7046   if (arg1) (arg1)->b = arg2;
7047 }
7048
7049
7050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7051   float jresult ;
7052   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7053   float result;
7054
7055   arg1 = (Dali::Vector3 *)jarg1;
7056   result = (float) ((arg1)->b);
7057   jresult = result;
7058   return jresult;
7059 }
7060
7061
7062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7063   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7064
7065   arg1 = (Dali::Vector3 *)jarg1;
7066   {
7067     try {
7068       delete arg1;
7069     } catch (std::out_of_range& e) {
7070       {
7071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7072       };
7073     } catch (std::exception& e) {
7074       {
7075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7076       };
7077     } catch (Dali::DaliException e) {
7078       {
7079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7080       };
7081     } catch (...) {
7082       {
7083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7084       };
7085     }
7086   }
7087
7088 }
7089
7090
7091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7092   void * jresult ;
7093   Dali::Vector3 *arg1 = 0 ;
7094   Dali::Vector3 *arg2 = 0 ;
7095   Dali::Vector3 result;
7096
7097   arg1 = (Dali::Vector3 *)jarg1;
7098   if (!arg1) {
7099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7100     return 0;
7101   }
7102   arg2 = (Dali::Vector3 *)jarg2;
7103   if (!arg2) {
7104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7105     return 0;
7106   }
7107   {
7108     try {
7109       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7110     } catch (std::out_of_range& e) {
7111       {
7112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7113       };
7114     } catch (std::exception& e) {
7115       {
7116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7117       };
7118     } catch (Dali::DaliException e) {
7119       {
7120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7121       };
7122     } catch (...) {
7123       {
7124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7125       };
7126     }
7127   }
7128
7129   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7130   return jresult;
7131 }
7132
7133
7134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7135   void * jresult ;
7136   Dali::Vector3 *arg1 = 0 ;
7137   Dali::Vector3 *arg2 = 0 ;
7138   Dali::Vector3 result;
7139
7140   arg1 = (Dali::Vector3 *)jarg1;
7141   if (!arg1) {
7142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7143     return 0;
7144   }
7145   arg2 = (Dali::Vector3 *)jarg2;
7146   if (!arg2) {
7147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7148     return 0;
7149   }
7150   {
7151     try {
7152       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7153     } catch (std::out_of_range& e) {
7154       {
7155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7156       };
7157     } catch (std::exception& e) {
7158       {
7159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (Dali::DaliException e) {
7162       {
7163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7164       };
7165     } catch (...) {
7166       {
7167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7168       };
7169     }
7170   }
7171
7172   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7173   return jresult;
7174 }
7175
7176
7177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7178   void * jresult ;
7179   Dali::Vector3 *arg1 = 0 ;
7180   float *arg2 = 0 ;
7181   float *arg3 = 0 ;
7182   float temp2 ;
7183   float temp3 ;
7184   Dali::Vector3 result;
7185
7186   arg1 = (Dali::Vector3 *)jarg1;
7187   if (!arg1) {
7188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7189     return 0;
7190   }
7191   temp2 = (float)jarg2;
7192   arg2 = &temp2;
7193   temp3 = (float)jarg3;
7194   arg3 = &temp3;
7195   {
7196     try {
7197       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7198     } catch (std::out_of_range& e) {
7199       {
7200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (std::exception& e) {
7203       {
7204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7205       };
7206     } catch (Dali::DaliException e) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7209       };
7210     } catch (...) {
7211       {
7212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7213       };
7214     }
7215   }
7216
7217   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7218   return jresult;
7219 }
7220
7221
7222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7223   void * jresult ;
7224   Dali::Vector4 *result = 0 ;
7225
7226   {
7227     try {
7228       result = (Dali::Vector4 *)new Dali::Vector4();
7229     } catch (std::out_of_range& e) {
7230       {
7231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7232       };
7233     } catch (std::exception& e) {
7234       {
7235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7236       };
7237     } catch (Dali::DaliException e) {
7238       {
7239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7240       };
7241     } catch (...) {
7242       {
7243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7244       };
7245     }
7246   }
7247
7248   jresult = (void *)result;
7249   return jresult;
7250 }
7251
7252
7253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7254   void * jresult ;
7255   float arg1 ;
7256   float arg2 ;
7257   float arg3 ;
7258   float arg4 ;
7259   Dali::Vector4 *result = 0 ;
7260
7261   arg1 = (float)jarg1;
7262   arg2 = (float)jarg2;
7263   arg3 = (float)jarg3;
7264   arg4 = (float)jarg4;
7265   {
7266     try {
7267       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7268     } catch (std::out_of_range& e) {
7269       {
7270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7271       };
7272     } catch (std::exception& e) {
7273       {
7274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7275       };
7276     } catch (Dali::DaliException e) {
7277       {
7278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7279       };
7280     } catch (...) {
7281       {
7282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7283       };
7284     }
7285   }
7286
7287   jresult = (void *)result;
7288   return jresult;
7289 }
7290
7291
7292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7293   void * jresult ;
7294   float *arg1 = (float *) 0 ;
7295   Dali::Vector4 *result = 0 ;
7296
7297   arg1 = jarg1;
7298   {
7299     try {
7300       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7301     } catch (std::out_of_range& e) {
7302       {
7303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7304       };
7305     } catch (std::exception& e) {
7306       {
7307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7308       };
7309     } catch (Dali::DaliException e) {
7310       {
7311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7312       };
7313     } catch (...) {
7314       {
7315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7316       };
7317     }
7318   }
7319
7320   jresult = (void *)result;
7321
7322
7323   return jresult;
7324 }
7325
7326
7327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7328   void * jresult ;
7329   Dali::Vector2 *arg1 = 0 ;
7330   Dali::Vector4 *result = 0 ;
7331
7332   arg1 = (Dali::Vector2 *)jarg1;
7333   if (!arg1) {
7334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7335     return 0;
7336   }
7337   {
7338     try {
7339       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7340     } catch (std::out_of_range& e) {
7341       {
7342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7343       };
7344     } catch (std::exception& e) {
7345       {
7346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7347       };
7348     } catch (Dali::DaliException e) {
7349       {
7350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7351       };
7352     } catch (...) {
7353       {
7354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7355       };
7356     }
7357   }
7358
7359   jresult = (void *)result;
7360   return jresult;
7361 }
7362
7363
7364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7365   void * jresult ;
7366   Dali::Vector3 *arg1 = 0 ;
7367   Dali::Vector4 *result = 0 ;
7368
7369   arg1 = (Dali::Vector3 *)jarg1;
7370   if (!arg1) {
7371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7372     return 0;
7373   }
7374   {
7375     try {
7376       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7377     } catch (std::out_of_range& e) {
7378       {
7379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7380       };
7381     } catch (std::exception& e) {
7382       {
7383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7384       };
7385     } catch (Dali::DaliException e) {
7386       {
7387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7388       };
7389     } catch (...) {
7390       {
7391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7392       };
7393     }
7394   }
7395
7396   jresult = (void *)result;
7397   return jresult;
7398 }
7399
7400
7401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7402   void * jresult ;
7403   Dali::Vector4 *result = 0 ;
7404
7405   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7406   jresult = (void *)result;
7407   return jresult;
7408 }
7409
7410
7411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7412   void * jresult ;
7413   Dali::Vector4 *result = 0 ;
7414
7415   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7416   jresult = (void *)result;
7417   return jresult;
7418 }
7419
7420
7421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7422   void * jresult ;
7423   Dali::Vector4 *result = 0 ;
7424
7425   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7426   jresult = (void *)result;
7427   return jresult;
7428 }
7429
7430
7431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7432   void * jresult ;
7433   Dali::Vector4 *result = 0 ;
7434
7435   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7436   jresult = (void *)result;
7437   return jresult;
7438 }
7439
7440
7441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7442   void * jresult ;
7443   Dali::Vector4 *result = 0 ;
7444
7445   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7446   jresult = (void *)result;
7447   return jresult;
7448 }
7449
7450
7451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7452   void * jresult ;
7453   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7454   float *arg2 = (float *) 0 ;
7455   Dali::Vector4 *result = 0 ;
7456
7457   arg1 = (Dali::Vector4 *)jarg1;
7458   arg2 = jarg2;
7459   {
7460     try {
7461       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7462     } catch (std::out_of_range& e) {
7463       {
7464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7465       };
7466     } catch (std::exception& e) {
7467       {
7468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7469       };
7470     } catch (Dali::DaliException e) {
7471       {
7472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7473       };
7474     } catch (...) {
7475       {
7476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7477       };
7478     }
7479   }
7480
7481   jresult = (void *)result;
7482
7483
7484   return jresult;
7485 }
7486
7487
7488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7489   void * jresult ;
7490   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7491   Dali::Vector2 *arg2 = 0 ;
7492   Dali::Vector4 *result = 0 ;
7493
7494   arg1 = (Dali::Vector4 *)jarg1;
7495   arg2 = (Dali::Vector2 *)jarg2;
7496   if (!arg2) {
7497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7498     return 0;
7499   }
7500   {
7501     try {
7502       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7503     } catch (std::out_of_range& e) {
7504       {
7505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7506       };
7507     } catch (std::exception& e) {
7508       {
7509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7510       };
7511     } catch (Dali::DaliException e) {
7512       {
7513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7514       };
7515     } catch (...) {
7516       {
7517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7518       };
7519     }
7520   }
7521
7522   jresult = (void *)result;
7523   return jresult;
7524 }
7525
7526
7527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7528   void * jresult ;
7529   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7530   Dali::Vector3 *arg2 = 0 ;
7531   Dali::Vector4 *result = 0 ;
7532
7533   arg1 = (Dali::Vector4 *)jarg1;
7534   arg2 = (Dali::Vector3 *)jarg2;
7535   if (!arg2) {
7536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7537     return 0;
7538   }
7539   {
7540     try {
7541       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7542     } catch (std::out_of_range& e) {
7543       {
7544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7545       };
7546     } catch (std::exception& e) {
7547       {
7548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7549       };
7550     } catch (Dali::DaliException e) {
7551       {
7552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7553       };
7554     } catch (...) {
7555       {
7556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7557       };
7558     }
7559   }
7560
7561   jresult = (void *)result;
7562   return jresult;
7563 }
7564
7565
7566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7567   void * jresult ;
7568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7569   Dali::Vector4 *arg2 = 0 ;
7570   Dali::Vector4 result;
7571
7572   arg1 = (Dali::Vector4 *)jarg1;
7573   arg2 = (Dali::Vector4 *)jarg2;
7574   if (!arg2) {
7575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7576     return 0;
7577   }
7578   {
7579     try {
7580       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7581     } catch (std::out_of_range& e) {
7582       {
7583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7584       };
7585     } catch (std::exception& e) {
7586       {
7587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7588       };
7589     } catch (Dali::DaliException e) {
7590       {
7591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7592       };
7593     } catch (...) {
7594       {
7595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7596       };
7597     }
7598   }
7599
7600   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7601   return jresult;
7602 }
7603
7604
7605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7606   void * jresult ;
7607   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7608   Dali::Vector4 *arg2 = 0 ;
7609   Dali::Vector4 *result = 0 ;
7610
7611   arg1 = (Dali::Vector4 *)jarg1;
7612   arg2 = (Dali::Vector4 *)jarg2;
7613   if (!arg2) {
7614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7615     return 0;
7616   }
7617   {
7618     try {
7619       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7620     } catch (std::out_of_range& e) {
7621       {
7622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7623       };
7624     } catch (std::exception& e) {
7625       {
7626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7627       };
7628     } catch (Dali::DaliException e) {
7629       {
7630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7631       };
7632     } catch (...) {
7633       {
7634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7635       };
7636     }
7637   }
7638
7639   jresult = (void *)result;
7640   return jresult;
7641 }
7642
7643
7644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7645   void * jresult ;
7646   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7647   Dali::Vector4 *arg2 = 0 ;
7648   Dali::Vector4 result;
7649
7650   arg1 = (Dali::Vector4 *)jarg1;
7651   arg2 = (Dali::Vector4 *)jarg2;
7652   if (!arg2) {
7653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7654     return 0;
7655   }
7656   {
7657     try {
7658       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7659     } catch (std::out_of_range& e) {
7660       {
7661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7662       };
7663     } catch (std::exception& e) {
7664       {
7665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7666       };
7667     } catch (Dali::DaliException e) {
7668       {
7669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7670       };
7671     } catch (...) {
7672       {
7673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7674       };
7675     }
7676   }
7677
7678   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7679   return jresult;
7680 }
7681
7682
7683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7684   void * jresult ;
7685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7686   Dali::Vector4 *arg2 = 0 ;
7687   Dali::Vector4 *result = 0 ;
7688
7689   arg1 = (Dali::Vector4 *)jarg1;
7690   arg2 = (Dali::Vector4 *)jarg2;
7691   if (!arg2) {
7692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7693     return 0;
7694   }
7695   {
7696     try {
7697       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7698     } catch (std::out_of_range& e) {
7699       {
7700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7701       };
7702     } catch (std::exception& e) {
7703       {
7704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7705       };
7706     } catch (Dali::DaliException e) {
7707       {
7708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7709       };
7710     } catch (...) {
7711       {
7712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7713       };
7714     }
7715   }
7716
7717   jresult = (void *)result;
7718   return jresult;
7719 }
7720
7721
7722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7723   void * jresult ;
7724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7725   Dali::Vector4 *arg2 = 0 ;
7726   Dali::Vector4 result;
7727
7728   arg1 = (Dali::Vector4 *)jarg1;
7729   arg2 = (Dali::Vector4 *)jarg2;
7730   if (!arg2) {
7731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7732     return 0;
7733   }
7734   {
7735     try {
7736       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7737     } catch (std::out_of_range& e) {
7738       {
7739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7740       };
7741     } catch (std::exception& e) {
7742       {
7743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7744       };
7745     } catch (Dali::DaliException e) {
7746       {
7747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7748       };
7749     } catch (...) {
7750       {
7751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7752       };
7753     }
7754   }
7755
7756   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7757   return jresult;
7758 }
7759
7760
7761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7762   void * jresult ;
7763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7764   float arg2 ;
7765   Dali::Vector4 result;
7766
7767   arg1 = (Dali::Vector4 *)jarg1;
7768   arg2 = (float)jarg2;
7769   {
7770     try {
7771       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7772     } catch (std::out_of_range& e) {
7773       {
7774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7775       };
7776     } catch (std::exception& e) {
7777       {
7778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7779       };
7780     } catch (Dali::DaliException e) {
7781       {
7782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7783       };
7784     } catch (...) {
7785       {
7786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7787       };
7788     }
7789   }
7790
7791   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7792   return jresult;
7793 }
7794
7795
7796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7797   void * jresult ;
7798   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7799   Dali::Vector4 *arg2 = 0 ;
7800   Dali::Vector4 *result = 0 ;
7801
7802   arg1 = (Dali::Vector4 *)jarg1;
7803   arg2 = (Dali::Vector4 *)jarg2;
7804   if (!arg2) {
7805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7806     return 0;
7807   }
7808   {
7809     try {
7810       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7811     } catch (std::out_of_range& e) {
7812       {
7813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7814       };
7815     } catch (std::exception& e) {
7816       {
7817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7818       };
7819     } catch (Dali::DaliException e) {
7820       {
7821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7822       };
7823     } catch (...) {
7824       {
7825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7826       };
7827     }
7828   }
7829
7830   jresult = (void *)result;
7831   return jresult;
7832 }
7833
7834
7835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7836   void * jresult ;
7837   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7838   float arg2 ;
7839   Dali::Vector4 *result = 0 ;
7840
7841   arg1 = (Dali::Vector4 *)jarg1;
7842   arg2 = (float)jarg2;
7843   {
7844     try {
7845       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7846     } catch (std::out_of_range& e) {
7847       {
7848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7849       };
7850     } catch (std::exception& e) {
7851       {
7852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7853       };
7854     } catch (Dali::DaliException e) {
7855       {
7856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7857       };
7858     } catch (...) {
7859       {
7860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7861       };
7862     }
7863   }
7864
7865   jresult = (void *)result;
7866   return jresult;
7867 }
7868
7869
7870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7871   void * jresult ;
7872   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7873   Dali::Vector4 *arg2 = 0 ;
7874   Dali::Vector4 result;
7875
7876   arg1 = (Dali::Vector4 *)jarg1;
7877   arg2 = (Dali::Vector4 *)jarg2;
7878   if (!arg2) {
7879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7880     return 0;
7881   }
7882   {
7883     try {
7884       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7885     } catch (std::out_of_range& e) {
7886       {
7887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7888       };
7889     } catch (std::exception& e) {
7890       {
7891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7892       };
7893     } catch (Dali::DaliException e) {
7894       {
7895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7896       };
7897     } catch (...) {
7898       {
7899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7900       };
7901     }
7902   }
7903
7904   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7905   return jresult;
7906 }
7907
7908
7909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7910   void * jresult ;
7911   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7912   float arg2 ;
7913   Dali::Vector4 result;
7914
7915   arg1 = (Dali::Vector4 *)jarg1;
7916   arg2 = (float)jarg2;
7917   {
7918     try {
7919       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7920     } catch (std::out_of_range& e) {
7921       {
7922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7923       };
7924     } catch (std::exception& e) {
7925       {
7926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7927       };
7928     } catch (Dali::DaliException e) {
7929       {
7930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7931       };
7932     } catch (...) {
7933       {
7934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7935       };
7936     }
7937   }
7938
7939   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7940   return jresult;
7941 }
7942
7943
7944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7945   void * jresult ;
7946   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7947   Dali::Vector4 *arg2 = 0 ;
7948   Dali::Vector4 *result = 0 ;
7949
7950   arg1 = (Dali::Vector4 *)jarg1;
7951   arg2 = (Dali::Vector4 *)jarg2;
7952   if (!arg2) {
7953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7954     return 0;
7955   }
7956   {
7957     try {
7958       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7959     } catch (std::out_of_range& e) {
7960       {
7961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7962       };
7963     } catch (std::exception& e) {
7964       {
7965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7966       };
7967     } catch (Dali::DaliException e) {
7968       {
7969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7970       };
7971     } catch (...) {
7972       {
7973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7974       };
7975     }
7976   }
7977
7978   jresult = (void *)result;
7979   return jresult;
7980 }
7981
7982
7983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7984   void * jresult ;
7985   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7986   float arg2 ;
7987   Dali::Vector4 *result = 0 ;
7988
7989   arg1 = (Dali::Vector4 *)jarg1;
7990   arg2 = (float)jarg2;
7991   {
7992     try {
7993       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7994     } catch (std::out_of_range& e) {
7995       {
7996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7997       };
7998     } catch (std::exception& e) {
7999       {
8000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8001       };
8002     } catch (Dali::DaliException e) {
8003       {
8004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8005       };
8006     } catch (...) {
8007       {
8008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8009       };
8010     }
8011   }
8012
8013   jresult = (void *)result;
8014   return jresult;
8015 }
8016
8017
8018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8019   void * jresult ;
8020   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8021   Dali::Vector4 result;
8022
8023   arg1 = (Dali::Vector4 *)jarg1;
8024   {
8025     try {
8026       result = ((Dali::Vector4 const *)arg1)->operator -();
8027     } catch (std::out_of_range& e) {
8028       {
8029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8030       };
8031     } catch (std::exception& e) {
8032       {
8033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8034       };
8035     } catch (Dali::DaliException e) {
8036       {
8037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8038       };
8039     } catch (...) {
8040       {
8041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8042       };
8043     }
8044   }
8045
8046   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8047   return jresult;
8048 }
8049
8050
8051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8052   unsigned int jresult ;
8053   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8054   Dali::Vector4 *arg2 = 0 ;
8055   bool result;
8056
8057   arg1 = (Dali::Vector4 *)jarg1;
8058   arg2 = (Dali::Vector4 *)jarg2;
8059   if (!arg2) {
8060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8061     return 0;
8062   }
8063   {
8064     try {
8065       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8066     } catch (std::out_of_range& e) {
8067       {
8068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8069       };
8070     } catch (std::exception& e) {
8071       {
8072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8073       };
8074     } catch (Dali::DaliException e) {
8075       {
8076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8077       };
8078     } catch (...) {
8079       {
8080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8081       };
8082     }
8083   }
8084
8085   jresult = result;
8086   return jresult;
8087 }
8088
8089
8090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8091   unsigned int jresult ;
8092   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8093   Dali::Vector4 *arg2 = 0 ;
8094   bool result;
8095
8096   arg1 = (Dali::Vector4 *)jarg1;
8097   arg2 = (Dali::Vector4 *)jarg2;
8098   if (!arg2) {
8099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8100     return 0;
8101   }
8102   {
8103     try {
8104       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8105     } catch (std::out_of_range& e) {
8106       {
8107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8108       };
8109     } catch (std::exception& e) {
8110       {
8111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8112       };
8113     } catch (Dali::DaliException e) {
8114       {
8115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8116       };
8117     } catch (...) {
8118       {
8119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8120       };
8121     }
8122   }
8123
8124   jresult = result;
8125   return jresult;
8126 }
8127
8128
8129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8130   float jresult ;
8131   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8132   unsigned int arg2 ;
8133   float *result = 0 ;
8134
8135   arg1 = (Dali::Vector4 *)jarg1;
8136   arg2 = (unsigned int)jarg2;
8137   {
8138     try {
8139       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8140     } catch (std::out_of_range& e) {
8141       {
8142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8143       };
8144     } catch (std::exception& e) {
8145       {
8146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8147       };
8148     } catch (Dali::DaliException e) {
8149       {
8150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8151       };
8152     } catch (...) {
8153       {
8154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8155       };
8156     }
8157   }
8158
8159   jresult = *result;
8160   return jresult;
8161 }
8162
8163
8164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8165   float jresult ;
8166   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8167   Dali::Vector3 *arg2 = 0 ;
8168   float result;
8169
8170   arg1 = (Dali::Vector4 *)jarg1;
8171   arg2 = (Dali::Vector3 *)jarg2;
8172   if (!arg2) {
8173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8174     return 0;
8175   }
8176   {
8177     try {
8178       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8179     } catch (std::out_of_range& e) {
8180       {
8181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8182       };
8183     } catch (std::exception& e) {
8184       {
8185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8186       };
8187     } catch (Dali::DaliException e) {
8188       {
8189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8190       };
8191     } catch (...) {
8192       {
8193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8194       };
8195     }
8196   }
8197
8198   jresult = result;
8199   return jresult;
8200 }
8201
8202
8203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8204   float jresult ;
8205   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8206   Dali::Vector4 *arg2 = 0 ;
8207   float result;
8208
8209   arg1 = (Dali::Vector4 *)jarg1;
8210   arg2 = (Dali::Vector4 *)jarg2;
8211   if (!arg2) {
8212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8213     return 0;
8214   }
8215   {
8216     try {
8217       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8218     } catch (std::out_of_range& e) {
8219       {
8220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8221       };
8222     } catch (std::exception& e) {
8223       {
8224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8225       };
8226     } catch (Dali::DaliException e) {
8227       {
8228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8229       };
8230     } catch (...) {
8231       {
8232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8233       };
8234     }
8235   }
8236
8237   jresult = result;
8238   return jresult;
8239 }
8240
8241
8242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8243   float jresult ;
8244   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8245   Dali::Vector4 *arg2 = 0 ;
8246   float result;
8247
8248   arg1 = (Dali::Vector4 *)jarg1;
8249   arg2 = (Dali::Vector4 *)jarg2;
8250   if (!arg2) {
8251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8252     return 0;
8253   }
8254   {
8255     try {
8256       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8257     } catch (std::out_of_range& e) {
8258       {
8259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8260       };
8261     } catch (std::exception& e) {
8262       {
8263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8264       };
8265     } catch (Dali::DaliException e) {
8266       {
8267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8268       };
8269     } catch (...) {
8270       {
8271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8272       };
8273     }
8274   }
8275
8276   jresult = result;
8277   return jresult;
8278 }
8279
8280
8281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8282   void * jresult ;
8283   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8284   Dali::Vector4 *arg2 = 0 ;
8285   Dali::Vector4 result;
8286
8287   arg1 = (Dali::Vector4 *)jarg1;
8288   arg2 = (Dali::Vector4 *)jarg2;
8289   if (!arg2) {
8290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8291     return 0;
8292   }
8293   {
8294     try {
8295       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8296     } catch (std::out_of_range& e) {
8297       {
8298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8299       };
8300     } catch (std::exception& e) {
8301       {
8302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8303       };
8304     } catch (Dali::DaliException e) {
8305       {
8306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8307       };
8308     } catch (...) {
8309       {
8310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8311       };
8312     }
8313   }
8314
8315   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8316   return jresult;
8317 }
8318
8319
8320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8321   float jresult ;
8322   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8323   float result;
8324
8325   arg1 = (Dali::Vector4 *)jarg1;
8326   {
8327     try {
8328       result = (float)((Dali::Vector4 const *)arg1)->Length();
8329     } catch (std::out_of_range& e) {
8330       {
8331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8332       };
8333     } catch (std::exception& e) {
8334       {
8335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8336       };
8337     } catch (Dali::DaliException e) {
8338       {
8339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8340       };
8341     } catch (...) {
8342       {
8343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8344       };
8345     }
8346   }
8347
8348   jresult = result;
8349   return jresult;
8350 }
8351
8352
8353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8354   float jresult ;
8355   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8356   float result;
8357
8358   arg1 = (Dali::Vector4 *)jarg1;
8359   {
8360     try {
8361       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8362     } catch (std::out_of_range& e) {
8363       {
8364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8365       };
8366     } catch (std::exception& e) {
8367       {
8368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8369       };
8370     } catch (Dali::DaliException e) {
8371       {
8372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8373       };
8374     } catch (...) {
8375       {
8376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8377       };
8378     }
8379   }
8380
8381   jresult = result;
8382   return jresult;
8383 }
8384
8385
8386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8387   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8388
8389   arg1 = (Dali::Vector4 *)jarg1;
8390   {
8391     try {
8392       (arg1)->Normalize();
8393     } catch (std::out_of_range& e) {
8394       {
8395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8396       };
8397     } catch (std::exception& e) {
8398       {
8399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8400       };
8401     } catch (Dali::DaliException e) {
8402       {
8403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8404       };
8405     } catch (...) {
8406       {
8407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8408       };
8409     }
8410   }
8411
8412 }
8413
8414
8415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8416   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8417   Dali::Vector4 *arg2 = 0 ;
8418   Dali::Vector4 *arg3 = 0 ;
8419
8420   arg1 = (Dali::Vector4 *)jarg1;
8421   arg2 = (Dali::Vector4 *)jarg2;
8422   if (!arg2) {
8423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8424     return ;
8425   }
8426   arg3 = (Dali::Vector4 *)jarg3;
8427   if (!arg3) {
8428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8429     return ;
8430   }
8431   {
8432     try {
8433       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8434     } catch (std::out_of_range& e) {
8435       {
8436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8437       };
8438     } catch (std::exception& e) {
8439       {
8440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8441       };
8442     } catch (Dali::DaliException e) {
8443       {
8444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8445       };
8446     } catch (...) {
8447       {
8448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8449       };
8450     }
8451   }
8452
8453 }
8454
8455
8456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8457   void * jresult ;
8458   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8459   float *result = 0 ;
8460
8461   arg1 = (Dali::Vector4 *)jarg1;
8462   {
8463     try {
8464       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8465     } catch (std::out_of_range& e) {
8466       {
8467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8468       };
8469     } catch (std::exception& e) {
8470       {
8471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8472       };
8473     } catch (Dali::DaliException e) {
8474       {
8475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8476       };
8477     } catch (...) {
8478       {
8479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8480       };
8481     }
8482   }
8483
8484   jresult = (void *)result;
8485   return jresult;
8486 }
8487
8488
8489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8490   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8491   float arg2 ;
8492
8493   arg1 = (Dali::Vector4 *)jarg1;
8494   arg2 = (float)jarg2;
8495   if (arg1) (arg1)->x = arg2;
8496 }
8497
8498
8499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8500   float jresult ;
8501   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8502   float result;
8503
8504   arg1 = (Dali::Vector4 *)jarg1;
8505   result = (float) ((arg1)->x);
8506   jresult = result;
8507   return jresult;
8508 }
8509
8510
8511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8512   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8513   float arg2 ;
8514
8515   arg1 = (Dali::Vector4 *)jarg1;
8516   arg2 = (float)jarg2;
8517   if (arg1) (arg1)->r = arg2;
8518 }
8519
8520
8521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8522   float jresult ;
8523   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8524   float result;
8525
8526   arg1 = (Dali::Vector4 *)jarg1;
8527   result = (float) ((arg1)->r);
8528   jresult = result;
8529   return jresult;
8530 }
8531
8532
8533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8535   float arg2 ;
8536
8537   arg1 = (Dali::Vector4 *)jarg1;
8538   arg2 = (float)jarg2;
8539   if (arg1) (arg1)->s = arg2;
8540 }
8541
8542
8543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8544   float jresult ;
8545   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8546   float result;
8547
8548   arg1 = (Dali::Vector4 *)jarg1;
8549   result = (float) ((arg1)->s);
8550   jresult = result;
8551   return jresult;
8552 }
8553
8554
8555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8556   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8557   float arg2 ;
8558
8559   arg1 = (Dali::Vector4 *)jarg1;
8560   arg2 = (float)jarg2;
8561   if (arg1) (arg1)->y = arg2;
8562 }
8563
8564
8565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8566   float jresult ;
8567   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8568   float result;
8569
8570   arg1 = (Dali::Vector4 *)jarg1;
8571   result = (float) ((arg1)->y);
8572   jresult = result;
8573   return jresult;
8574 }
8575
8576
8577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8578   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8579   float arg2 ;
8580
8581   arg1 = (Dali::Vector4 *)jarg1;
8582   arg2 = (float)jarg2;
8583   if (arg1) (arg1)->g = arg2;
8584 }
8585
8586
8587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8588   float jresult ;
8589   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8590   float result;
8591
8592   arg1 = (Dali::Vector4 *)jarg1;
8593   result = (float) ((arg1)->g);
8594   jresult = result;
8595   return jresult;
8596 }
8597
8598
8599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8600   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8601   float arg2 ;
8602
8603   arg1 = (Dali::Vector4 *)jarg1;
8604   arg2 = (float)jarg2;
8605   if (arg1) (arg1)->t = arg2;
8606 }
8607
8608
8609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8610   float jresult ;
8611   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8612   float result;
8613
8614   arg1 = (Dali::Vector4 *)jarg1;
8615   result = (float) ((arg1)->t);
8616   jresult = result;
8617   return jresult;
8618 }
8619
8620
8621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8622   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8623   float arg2 ;
8624
8625   arg1 = (Dali::Vector4 *)jarg1;
8626   arg2 = (float)jarg2;
8627   if (arg1) (arg1)->z = arg2;
8628 }
8629
8630
8631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8632   float jresult ;
8633   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8634   float result;
8635
8636   arg1 = (Dali::Vector4 *)jarg1;
8637   result = (float) ((arg1)->z);
8638   jresult = result;
8639   return jresult;
8640 }
8641
8642
8643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8644   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8645   float arg2 ;
8646
8647   arg1 = (Dali::Vector4 *)jarg1;
8648   arg2 = (float)jarg2;
8649   if (arg1) (arg1)->b = arg2;
8650 }
8651
8652
8653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8654   float jresult ;
8655   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8656   float result;
8657
8658   arg1 = (Dali::Vector4 *)jarg1;
8659   result = (float) ((arg1)->b);
8660   jresult = result;
8661   return jresult;
8662 }
8663
8664
8665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8666   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8667   float arg2 ;
8668
8669   arg1 = (Dali::Vector4 *)jarg1;
8670   arg2 = (float)jarg2;
8671   if (arg1) (arg1)->p = arg2;
8672 }
8673
8674
8675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8676   float jresult ;
8677   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8678   float result;
8679
8680   arg1 = (Dali::Vector4 *)jarg1;
8681   result = (float) ((arg1)->p);
8682   jresult = result;
8683   return jresult;
8684 }
8685
8686
8687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8688   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8689   float arg2 ;
8690
8691   arg1 = (Dali::Vector4 *)jarg1;
8692   arg2 = (float)jarg2;
8693   if (arg1) (arg1)->w = arg2;
8694 }
8695
8696
8697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8698   float jresult ;
8699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8700   float result;
8701
8702   arg1 = (Dali::Vector4 *)jarg1;
8703   result = (float) ((arg1)->w);
8704   jresult = result;
8705   return jresult;
8706 }
8707
8708
8709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8710   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8711   float arg2 ;
8712
8713   arg1 = (Dali::Vector4 *)jarg1;
8714   arg2 = (float)jarg2;
8715   if (arg1) (arg1)->a = arg2;
8716 }
8717
8718
8719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8720   float jresult ;
8721   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8722   float result;
8723
8724   arg1 = (Dali::Vector4 *)jarg1;
8725   result = (float) ((arg1)->a);
8726   jresult = result;
8727   return jresult;
8728 }
8729
8730
8731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8733   float arg2 ;
8734
8735   arg1 = (Dali::Vector4 *)jarg1;
8736   arg2 = (float)jarg2;
8737   if (arg1) (arg1)->q = arg2;
8738 }
8739
8740
8741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8742   float jresult ;
8743   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8744   float result;
8745
8746   arg1 = (Dali::Vector4 *)jarg1;
8747   result = (float) ((arg1)->q);
8748   jresult = result;
8749   return jresult;
8750 }
8751
8752
8753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8754   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8755
8756   arg1 = (Dali::Vector4 *)jarg1;
8757   {
8758     try {
8759       delete arg1;
8760     } catch (std::out_of_range& e) {
8761       {
8762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8763       };
8764     } catch (std::exception& e) {
8765       {
8766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8767       };
8768     } catch (Dali::DaliException e) {
8769       {
8770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8771       };
8772     } catch (...) {
8773       {
8774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8775       };
8776     }
8777   }
8778
8779 }
8780
8781
8782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8783   void * jresult ;
8784   Dali::Vector4 *arg1 = 0 ;
8785   Dali::Vector4 *arg2 = 0 ;
8786   Dali::Vector4 result;
8787
8788   arg1 = (Dali::Vector4 *)jarg1;
8789   if (!arg1) {
8790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8791     return 0;
8792   }
8793   arg2 = (Dali::Vector4 *)jarg2;
8794   if (!arg2) {
8795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8796     return 0;
8797   }
8798   {
8799     try {
8800       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8801     } catch (std::out_of_range& e) {
8802       {
8803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8804       };
8805     } catch (std::exception& e) {
8806       {
8807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8808       };
8809     } catch (Dali::DaliException e) {
8810       {
8811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8812       };
8813     } catch (...) {
8814       {
8815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8816       };
8817     }
8818   }
8819
8820   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8821   return jresult;
8822 }
8823
8824
8825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8826   void * jresult ;
8827   Dali::Vector4 *arg1 = 0 ;
8828   Dali::Vector4 *arg2 = 0 ;
8829   Dali::Vector4 result;
8830
8831   arg1 = (Dali::Vector4 *)jarg1;
8832   if (!arg1) {
8833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8834     return 0;
8835   }
8836   arg2 = (Dali::Vector4 *)jarg2;
8837   if (!arg2) {
8838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8839     return 0;
8840   }
8841   {
8842     try {
8843       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8844     } catch (std::out_of_range& e) {
8845       {
8846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8847       };
8848     } catch (std::exception& e) {
8849       {
8850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8851       };
8852     } catch (Dali::DaliException e) {
8853       {
8854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8855       };
8856     } catch (...) {
8857       {
8858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8859       };
8860     }
8861   }
8862
8863   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8864   return jresult;
8865 }
8866
8867
8868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8869   void * jresult ;
8870   Dali::Vector4 *arg1 = 0 ;
8871   float *arg2 = 0 ;
8872   float *arg3 = 0 ;
8873   float temp2 ;
8874   float temp3 ;
8875   Dali::Vector4 result;
8876
8877   arg1 = (Dali::Vector4 *)jarg1;
8878   if (!arg1) {
8879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8880     return 0;
8881   }
8882   temp2 = (float)jarg2;
8883   arg2 = &temp2;
8884   temp3 = (float)jarg3;
8885   arg3 = &temp3;
8886   {
8887     try {
8888       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8889     } catch (std::out_of_range& e) {
8890       {
8891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8892       };
8893     } catch (std::exception& e) {
8894       {
8895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8896       };
8897     } catch (Dali::DaliException e) {
8898       {
8899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8900       };
8901     } catch (...) {
8902       {
8903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8904       };
8905     }
8906   }
8907
8908   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8909   return jresult;
8910 }
8911
8912
8913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8914   void * jresult ;
8915   Dali::Uint16Pair *result = 0 ;
8916
8917   {
8918     try {
8919       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8920     } catch (std::out_of_range& e) {
8921       {
8922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8923       };
8924     } catch (std::exception& e) {
8925       {
8926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8927       };
8928     } catch (Dali::DaliException e) {
8929       {
8930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8931       };
8932     } catch (...) {
8933       {
8934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8935       };
8936     }
8937   }
8938
8939   jresult = (void *)result;
8940   return jresult;
8941 }
8942
8943
8944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8945   void * jresult ;
8946   uint32_t arg1 ;
8947   uint32_t arg2 ;
8948   Dali::Uint16Pair *result = 0 ;
8949
8950   arg1 = (uint32_t)jarg1;
8951   arg2 = (uint32_t)jarg2;
8952   {
8953     try {
8954       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8955     } catch (std::out_of_range& e) {
8956       {
8957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8958       };
8959     } catch (std::exception& e) {
8960       {
8961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8962       };
8963     } catch (Dali::DaliException e) {
8964       {
8965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8966       };
8967     } catch (...) {
8968       {
8969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8970       };
8971     }
8972   }
8973
8974   jresult = (void *)result;
8975   return jresult;
8976 }
8977
8978
8979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8980   void * jresult ;
8981   Dali::Uint16Pair *arg1 = 0 ;
8982   Dali::Uint16Pair *result = 0 ;
8983
8984   arg1 = (Dali::Uint16Pair *)jarg1;
8985   if (!arg1) {
8986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8987     return 0;
8988   }
8989   {
8990     try {
8991       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8992     } catch (std::out_of_range& e) {
8993       {
8994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8995       };
8996     } catch (std::exception& e) {
8997       {
8998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8999       };
9000     } catch (Dali::DaliException e) {
9001       {
9002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9003       };
9004     } catch (...) {
9005       {
9006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9007       };
9008     }
9009   }
9010
9011   jresult = (void *)result;
9012   return jresult;
9013 }
9014
9015
9016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9017   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9018   uint16_t arg2 ;
9019
9020   arg1 = (Dali::Uint16Pair *)jarg1;
9021   arg2 = (uint16_t)jarg2;
9022   {
9023     try {
9024       (arg1)->SetWidth(arg2);
9025     } catch (std::out_of_range& e) {
9026       {
9027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9028       };
9029     } catch (std::exception& e) {
9030       {
9031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9032       };
9033     } catch (Dali::DaliException e) {
9034       {
9035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9036       };
9037     } catch (...) {
9038       {
9039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9040       };
9041     }
9042   }
9043
9044 }
9045
9046
9047 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9048   unsigned short jresult ;
9049   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9050   uint16_t result;
9051
9052   arg1 = (Dali::Uint16Pair *)jarg1;
9053   {
9054     try {
9055       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9056     } catch (std::out_of_range& e) {
9057       {
9058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9059       };
9060     } catch (std::exception& e) {
9061       {
9062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9063       };
9064     } catch (Dali::DaliException e) {
9065       {
9066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9067       };
9068     } catch (...) {
9069       {
9070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9071       };
9072     }
9073   }
9074
9075   jresult = result;
9076   return jresult;
9077 }
9078
9079
9080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9081   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9082   uint16_t arg2 ;
9083
9084   arg1 = (Dali::Uint16Pair *)jarg1;
9085   arg2 = (uint16_t)jarg2;
9086   {
9087     try {
9088       (arg1)->SetHeight(arg2);
9089     } catch (std::out_of_range& e) {
9090       {
9091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9092       };
9093     } catch (std::exception& e) {
9094       {
9095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9096       };
9097     } catch (Dali::DaliException e) {
9098       {
9099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9100       };
9101     } catch (...) {
9102       {
9103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9104       };
9105     }
9106   }
9107
9108 }
9109
9110
9111 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9112   unsigned short jresult ;
9113   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9114   uint16_t result;
9115
9116   arg1 = (Dali::Uint16Pair *)jarg1;
9117   {
9118     try {
9119       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9120     } catch (std::out_of_range& e) {
9121       {
9122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9123       };
9124     } catch (std::exception& e) {
9125       {
9126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9127       };
9128     } catch (Dali::DaliException e) {
9129       {
9130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9131       };
9132     } catch (...) {
9133       {
9134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9135       };
9136     }
9137   }
9138
9139   jresult = result;
9140   return jresult;
9141 }
9142
9143
9144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9145   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9146   uint16_t arg2 ;
9147
9148   arg1 = (Dali::Uint16Pair *)jarg1;
9149   arg2 = (uint16_t)jarg2;
9150   {
9151     try {
9152       (arg1)->SetX(arg2);
9153     } catch (std::out_of_range& e) {
9154       {
9155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9156       };
9157     } catch (std::exception& e) {
9158       {
9159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9160       };
9161     } catch (Dali::DaliException e) {
9162       {
9163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9164       };
9165     } catch (...) {
9166       {
9167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9168       };
9169     }
9170   }
9171
9172 }
9173
9174
9175 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9176   unsigned short jresult ;
9177   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9178   uint16_t result;
9179
9180   arg1 = (Dali::Uint16Pair *)jarg1;
9181   {
9182     try {
9183       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9184     } catch (std::out_of_range& e) {
9185       {
9186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9187       };
9188     } catch (std::exception& e) {
9189       {
9190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9191       };
9192     } catch (Dali::DaliException e) {
9193       {
9194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9195       };
9196     } catch (...) {
9197       {
9198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9199       };
9200     }
9201   }
9202
9203   jresult = result;
9204   return jresult;
9205 }
9206
9207
9208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9209   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9210   uint16_t arg2 ;
9211
9212   arg1 = (Dali::Uint16Pair *)jarg1;
9213   arg2 = (uint16_t)jarg2;
9214   {
9215     try {
9216       (arg1)->SetY(arg2);
9217     } catch (std::out_of_range& e) {
9218       {
9219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9220       };
9221     } catch (std::exception& e) {
9222       {
9223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9224       };
9225     } catch (Dali::DaliException e) {
9226       {
9227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9228       };
9229     } catch (...) {
9230       {
9231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9232       };
9233     }
9234   }
9235
9236 }
9237
9238
9239 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9240   unsigned short jresult ;
9241   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9242   uint16_t result;
9243
9244   arg1 = (Dali::Uint16Pair *)jarg1;
9245   {
9246     try {
9247       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9248     } catch (std::out_of_range& e) {
9249       {
9250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9251       };
9252     } catch (std::exception& e) {
9253       {
9254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9255       };
9256     } catch (Dali::DaliException e) {
9257       {
9258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9259       };
9260     } catch (...) {
9261       {
9262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9263       };
9264     }
9265   }
9266
9267   jresult = result;
9268   return jresult;
9269 }
9270
9271
9272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9273   void * jresult ;
9274   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9275   Dali::Uint16Pair *arg2 = 0 ;
9276   Dali::Uint16Pair *result = 0 ;
9277
9278   arg1 = (Dali::Uint16Pair *)jarg1;
9279   arg2 = (Dali::Uint16Pair *)jarg2;
9280   if (!arg2) {
9281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9282     return 0;
9283   }
9284   {
9285     try {
9286       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9287     } catch (std::out_of_range& e) {
9288       {
9289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9290       };
9291     } catch (std::exception& e) {
9292       {
9293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9294       };
9295     } catch (Dali::DaliException e) {
9296       {
9297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9298       };
9299     } catch (...) {
9300       {
9301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9302       };
9303     }
9304   }
9305
9306   jresult = (void *)result;
9307   return jresult;
9308 }
9309
9310
9311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9312   unsigned int jresult ;
9313   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9314   Dali::Uint16Pair *arg2 = 0 ;
9315   bool result;
9316
9317   arg1 = (Dali::Uint16Pair *)jarg1;
9318   arg2 = (Dali::Uint16Pair *)jarg2;
9319   if (!arg2) {
9320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9321     return 0;
9322   }
9323   {
9324     try {
9325       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9326     } catch (std::out_of_range& e) {
9327       {
9328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9329       };
9330     } catch (std::exception& e) {
9331       {
9332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9333       };
9334     } catch (Dali::DaliException e) {
9335       {
9336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9337       };
9338     } catch (...) {
9339       {
9340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9341       };
9342     }
9343   }
9344
9345   jresult = result;
9346   return jresult;
9347 }
9348
9349
9350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9351   unsigned int jresult ;
9352   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9353   Dali::Uint16Pair *arg2 = 0 ;
9354   bool result;
9355
9356   arg1 = (Dali::Uint16Pair *)jarg1;
9357   arg2 = (Dali::Uint16Pair *)jarg2;
9358   if (!arg2) {
9359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9360     return 0;
9361   }
9362   {
9363     try {
9364       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9365     } catch (std::out_of_range& e) {
9366       {
9367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9368       };
9369     } catch (std::exception& e) {
9370       {
9371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9372       };
9373     } catch (Dali::DaliException e) {
9374       {
9375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9376       };
9377     } catch (...) {
9378       {
9379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9380       };
9381     }
9382   }
9383
9384   jresult = result;
9385   return jresult;
9386 }
9387
9388
9389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9390   unsigned int jresult ;
9391   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9392   Dali::Uint16Pair *arg2 = 0 ;
9393   bool result;
9394
9395   arg1 = (Dali::Uint16Pair *)jarg1;
9396   arg2 = (Dali::Uint16Pair *)jarg2;
9397   if (!arg2) {
9398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9399     return 0;
9400   }
9401   {
9402     try {
9403       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9404     } catch (std::out_of_range& e) {
9405       {
9406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9407       };
9408     } catch (std::exception& e) {
9409       {
9410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9411       };
9412     } catch (Dali::DaliException e) {
9413       {
9414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9415       };
9416     } catch (...) {
9417       {
9418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9419       };
9420     }
9421   }
9422
9423   jresult = result;
9424   return jresult;
9425 }
9426
9427
9428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9429   unsigned int jresult ;
9430   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9431   Dali::Uint16Pair *arg2 = 0 ;
9432   bool result;
9433
9434   arg1 = (Dali::Uint16Pair *)jarg1;
9435   arg2 = (Dali::Uint16Pair *)jarg2;
9436   if (!arg2) {
9437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9438     return 0;
9439   }
9440   {
9441     try {
9442       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9443     } catch (std::out_of_range& e) {
9444       {
9445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9446       };
9447     } catch (std::exception& e) {
9448       {
9449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9450       };
9451     } catch (Dali::DaliException e) {
9452       {
9453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9454       };
9455     } catch (...) {
9456       {
9457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9458       };
9459     }
9460   }
9461
9462   jresult = result;
9463   return jresult;
9464 }
9465
9466
9467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9468   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9469
9470   arg1 = (Dali::Uint16Pair *)jarg1;
9471   {
9472     try {
9473       delete arg1;
9474     } catch (std::out_of_range& e) {
9475       {
9476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9477       };
9478     } catch (std::exception& e) {
9479       {
9480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9481       };
9482     } catch (Dali::DaliException e) {
9483       {
9484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9485       };
9486     } catch (...) {
9487       {
9488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9489       };
9490     }
9491   }
9492
9493 }
9494
9495
9496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9497   void * jresult ;
9498   Dali::Degree *result = 0 ;
9499
9500   {
9501     try {
9502       result = (Dali::Degree *)new Dali::Degree();
9503     } catch (std::out_of_range& e) {
9504       {
9505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9506       };
9507     } catch (std::exception& e) {
9508       {
9509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9510       };
9511     } catch (Dali::DaliException e) {
9512       {
9513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9514       };
9515     } catch (...) {
9516       {
9517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9518       };
9519     }
9520   }
9521
9522   jresult = (void *)result;
9523   return jresult;
9524 }
9525
9526
9527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9528   void * jresult ;
9529   float arg1 ;
9530   Dali::Degree *result = 0 ;
9531
9532   arg1 = (float)jarg1;
9533   {
9534     try {
9535       result = (Dali::Degree *)new Dali::Degree(arg1);
9536     } catch (std::out_of_range& e) {
9537       {
9538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9539       };
9540     } catch (std::exception& e) {
9541       {
9542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9543       };
9544     } catch (Dali::DaliException e) {
9545       {
9546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9547       };
9548     } catch (...) {
9549       {
9550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9551       };
9552     }
9553   }
9554
9555   jresult = (void *)result;
9556   return jresult;
9557 }
9558
9559
9560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9561   void * jresult ;
9562   Dali::Radian arg1 ;
9563   Dali::Radian *argp1 ;
9564   Dali::Degree *result = 0 ;
9565
9566   argp1 = (Dali::Radian *)jarg1;
9567   if (!argp1) {
9568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9569     return 0;
9570   }
9571   arg1 = *argp1;
9572   {
9573     try {
9574       result = (Dali::Degree *)new Dali::Degree(arg1);
9575     } catch (std::out_of_range& e) {
9576       {
9577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9578       };
9579     } catch (std::exception& e) {
9580       {
9581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9582       };
9583     } catch (Dali::DaliException e) {
9584       {
9585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9586       };
9587     } catch (...) {
9588       {
9589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9590       };
9591     }
9592   }
9593
9594   jresult = (void *)result;
9595   return jresult;
9596 }
9597
9598
9599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9600   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9601   float arg2 ;
9602
9603   arg1 = (Dali::Degree *)jarg1;
9604   arg2 = (float)jarg2;
9605   if (arg1) (arg1)->degree = arg2;
9606 }
9607
9608
9609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9610   float jresult ;
9611   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9612   float result;
9613
9614   arg1 = (Dali::Degree *)jarg1;
9615   result = (float) ((arg1)->degree);
9616   jresult = result;
9617   return jresult;
9618 }
9619
9620
9621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9622   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9623
9624   arg1 = (Dali::Degree *)jarg1;
9625   {
9626     try {
9627       delete arg1;
9628     } catch (std::out_of_range& e) {
9629       {
9630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9631       };
9632     } catch (std::exception& e) {
9633       {
9634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9635       };
9636     } catch (Dali::DaliException e) {
9637       {
9638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9639       };
9640     } catch (...) {
9641       {
9642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9643       };
9644     }
9645   }
9646
9647 }
9648
9649
9650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9651   void * jresult ;
9652   Dali::Radian *result = 0 ;
9653
9654   result = (Dali::Radian *)&Dali::ANGLE_360;
9655   jresult = (void *)result;
9656   return jresult;
9657 }
9658
9659
9660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9661   void * jresult ;
9662   Dali::Radian *result = 0 ;
9663
9664   result = (Dali::Radian *)&Dali::ANGLE_315;
9665   jresult = (void *)result;
9666   return jresult;
9667 }
9668
9669
9670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9671   void * jresult ;
9672   Dali::Radian *result = 0 ;
9673
9674   result = (Dali::Radian *)&Dali::ANGLE_270;
9675   jresult = (void *)result;
9676   return jresult;
9677 }
9678
9679
9680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9681   void * jresult ;
9682   Dali::Radian *result = 0 ;
9683
9684   result = (Dali::Radian *)&Dali::ANGLE_225;
9685   jresult = (void *)result;
9686   return jresult;
9687 }
9688
9689
9690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9691   void * jresult ;
9692   Dali::Radian *result = 0 ;
9693
9694   result = (Dali::Radian *)&Dali::ANGLE_180;
9695   jresult = (void *)result;
9696   return jresult;
9697 }
9698
9699
9700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9701   void * jresult ;
9702   Dali::Radian *result = 0 ;
9703
9704   result = (Dali::Radian *)&Dali::ANGLE_135;
9705   jresult = (void *)result;
9706   return jresult;
9707 }
9708
9709
9710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9711   void * jresult ;
9712   Dali::Radian *result = 0 ;
9713
9714   result = (Dali::Radian *)&Dali::ANGLE_120;
9715   jresult = (void *)result;
9716   return jresult;
9717 }
9718
9719
9720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9721   void * jresult ;
9722   Dali::Radian *result = 0 ;
9723
9724   result = (Dali::Radian *)&Dali::ANGLE_90;
9725   jresult = (void *)result;
9726   return jresult;
9727 }
9728
9729
9730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9731   void * jresult ;
9732   Dali::Radian *result = 0 ;
9733
9734   result = (Dali::Radian *)&Dali::ANGLE_60;
9735   jresult = (void *)result;
9736   return jresult;
9737 }
9738
9739
9740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9741   void * jresult ;
9742   Dali::Radian *result = 0 ;
9743
9744   result = (Dali::Radian *)&Dali::ANGLE_45;
9745   jresult = (void *)result;
9746   return jresult;
9747 }
9748
9749
9750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9751   void * jresult ;
9752   Dali::Radian *result = 0 ;
9753
9754   result = (Dali::Radian *)&Dali::ANGLE_30;
9755   jresult = (void *)result;
9756   return jresult;
9757 }
9758
9759
9760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9761   void * jresult ;
9762   Dali::Radian *result = 0 ;
9763
9764   result = (Dali::Radian *)&Dali::ANGLE_0;
9765   jresult = (void *)result;
9766   return jresult;
9767 }
9768
9769
9770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9771   unsigned int jresult ;
9772   Dali::Degree *arg1 = 0 ;
9773   Dali::Degree *arg2 = 0 ;
9774   bool result;
9775
9776   arg1 = (Dali::Degree *)jarg1;
9777   if (!arg1) {
9778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9779     return 0;
9780   }
9781   arg2 = (Dali::Degree *)jarg2;
9782   if (!arg2) {
9783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9784     return 0;
9785   }
9786   {
9787     try {
9788       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9789     } catch (std::out_of_range& e) {
9790       {
9791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9792       };
9793     } catch (std::exception& e) {
9794       {
9795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9796       };
9797     } catch (Dali::DaliException e) {
9798       {
9799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9800       };
9801     } catch (...) {
9802       {
9803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9804       };
9805     }
9806   }
9807
9808   jresult = result;
9809   return jresult;
9810 }
9811
9812
9813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9814   unsigned int jresult ;
9815   Dali::Degree *arg1 = 0 ;
9816   Dali::Degree *arg2 = 0 ;
9817   bool result;
9818
9819   arg1 = (Dali::Degree *)jarg1;
9820   if (!arg1) {
9821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9822     return 0;
9823   }
9824   arg2 = (Dali::Degree *)jarg2;
9825   if (!arg2) {
9826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9827     return 0;
9828   }
9829   {
9830     try {
9831       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9832     } catch (std::out_of_range& e) {
9833       {
9834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9835       };
9836     } catch (std::exception& e) {
9837       {
9838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (Dali::DaliException e) {
9841       {
9842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9843       };
9844     } catch (...) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9847       };
9848     }
9849   }
9850
9851   jresult = result;
9852   return jresult;
9853 }
9854
9855
9856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9857   void * jresult ;
9858   Dali::Degree arg1 ;
9859   float arg2 ;
9860   float arg3 ;
9861   Dali::Degree *argp1 ;
9862   Dali::Degree result;
9863
9864   argp1 = (Dali::Degree *)jarg1;
9865   if (!argp1) {
9866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9867     return 0;
9868   }
9869   arg1 = *argp1;
9870   arg2 = (float)jarg2;
9871   arg3 = (float)jarg3;
9872   {
9873     try {
9874       result = Dali::Clamp(arg1,arg2,arg3);
9875     } catch (std::out_of_range& e) {
9876       {
9877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9878       };
9879     } catch (std::exception& e) {
9880       {
9881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9882       };
9883     } catch (Dali::DaliException e) {
9884       {
9885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9886       };
9887     } catch (...) {
9888       {
9889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9890       };
9891     }
9892   }
9893
9894   jresult = new Dali::Degree((const Dali::Degree &)result);
9895   return jresult;
9896 }
9897
9898
9899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9900   void * jresult ;
9901   Dali::Radian *result = 0 ;
9902
9903   {
9904     try {
9905       result = (Dali::Radian *)new Dali::Radian();
9906     } catch (std::out_of_range& e) {
9907       {
9908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9909       };
9910     } catch (std::exception& e) {
9911       {
9912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9913       };
9914     } catch (Dali::DaliException e) {
9915       {
9916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9917       };
9918     } catch (...) {
9919       {
9920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9921       };
9922     }
9923   }
9924
9925   jresult = (void *)result;
9926   return jresult;
9927 }
9928
9929
9930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9931   void * jresult ;
9932   float arg1 ;
9933   Dali::Radian *result = 0 ;
9934
9935   arg1 = (float)jarg1;
9936   {
9937     try {
9938       result = (Dali::Radian *)new Dali::Radian(arg1);
9939     } catch (std::out_of_range& e) {
9940       {
9941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9942       };
9943     } catch (std::exception& e) {
9944       {
9945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9946       };
9947     } catch (Dali::DaliException e) {
9948       {
9949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9950       };
9951     } catch (...) {
9952       {
9953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9954       };
9955     }
9956   }
9957
9958   jresult = (void *)result;
9959   return jresult;
9960 }
9961
9962
9963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9964   void * jresult ;
9965   Dali::Degree arg1 ;
9966   Dali::Degree *argp1 ;
9967   Dali::Radian *result = 0 ;
9968
9969   argp1 = (Dali::Degree *)jarg1;
9970   if (!argp1) {
9971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9972     return 0;
9973   }
9974   arg1 = *argp1;
9975   {
9976     try {
9977       result = (Dali::Radian *)new Dali::Radian(arg1);
9978     } catch (std::out_of_range& e) {
9979       {
9980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9981       };
9982     } catch (std::exception& e) {
9983       {
9984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9985       };
9986     } catch (Dali::DaliException e) {
9987       {
9988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9989       };
9990     } catch (...) {
9991       {
9992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9993       };
9994     }
9995   }
9996
9997   jresult = (void *)result;
9998   return jresult;
9999 }
10000
10001
10002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10003   void * jresult ;
10004   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10005   float arg2 ;
10006   Dali::Radian *result = 0 ;
10007
10008   arg1 = (Dali::Radian *)jarg1;
10009   arg2 = (float)jarg2;
10010   {
10011     try {
10012       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10013     } catch (std::out_of_range& e) {
10014       {
10015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10016       };
10017     } catch (std::exception& e) {
10018       {
10019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10020       };
10021     } catch (Dali::DaliException e) {
10022       {
10023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10024       };
10025     } catch (...) {
10026       {
10027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10028       };
10029     }
10030   }
10031
10032   jresult = (void *)result;
10033   return jresult;
10034 }
10035
10036
10037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10038   void * jresult ;
10039   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10040   Dali::Degree arg2 ;
10041   Dali::Degree *argp2 ;
10042   Dali::Radian *result = 0 ;
10043
10044   arg1 = (Dali::Radian *)jarg1;
10045   argp2 = (Dali::Degree *)jarg2;
10046   if (!argp2) {
10047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10048     return 0;
10049   }
10050   arg2 = *argp2;
10051   {
10052     try {
10053       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10054     } catch (std::out_of_range& e) {
10055       {
10056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10057       };
10058     } catch (std::exception& e) {
10059       {
10060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10061       };
10062     } catch (Dali::DaliException e) {
10063       {
10064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10065       };
10066     } catch (...) {
10067       {
10068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10069       };
10070     }
10071   }
10072
10073   jresult = (void *)result;
10074   return jresult;
10075 }
10076
10077
10078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10079   float jresult ;
10080   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10081   float result;
10082
10083   arg1 = (Dali::Radian *)jarg1;
10084   {
10085     try {
10086       result = (float)((Dali::Radian const *)arg1)->operator float();
10087     } catch (std::out_of_range& e) {
10088       {
10089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10090       };
10091     } catch (std::exception& e) {
10092       {
10093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10094       };
10095     } catch (Dali::DaliException e) {
10096       {
10097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10098       };
10099     } catch (...) {
10100       {
10101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10102       };
10103     }
10104   }
10105
10106   jresult = result;
10107   return jresult;
10108 }
10109
10110
10111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10112   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10113   float arg2 ;
10114
10115   arg1 = (Dali::Radian *)jarg1;
10116   arg2 = (float)jarg2;
10117   if (arg1) (arg1)->radian = arg2;
10118 }
10119
10120
10121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10122   float jresult ;
10123   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10124   float result;
10125
10126   arg1 = (Dali::Radian *)jarg1;
10127   result = (float) ((arg1)->radian);
10128   jresult = result;
10129   return jresult;
10130 }
10131
10132
10133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10134   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10135
10136   arg1 = (Dali::Radian *)jarg1;
10137   {
10138     try {
10139       delete arg1;
10140     } catch (std::out_of_range& e) {
10141       {
10142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10143       };
10144     } catch (std::exception& e) {
10145       {
10146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10147       };
10148     } catch (Dali::DaliException e) {
10149       {
10150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10151       };
10152     } catch (...) {
10153       {
10154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10155       };
10156     }
10157   }
10158
10159 }
10160
10161
10162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10163   unsigned int jresult ;
10164   Dali::Radian arg1 ;
10165   Dali::Radian arg2 ;
10166   Dali::Radian *argp1 ;
10167   Dali::Radian *argp2 ;
10168   bool result;
10169
10170   argp1 = (Dali::Radian *)jarg1;
10171   if (!argp1) {
10172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10173     return 0;
10174   }
10175   arg1 = *argp1;
10176   argp2 = (Dali::Radian *)jarg2;
10177   if (!argp2) {
10178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10179     return 0;
10180   }
10181   arg2 = *argp2;
10182   {
10183     try {
10184       result = (bool)Dali::operator ==(arg1,arg2);
10185     } catch (std::out_of_range& e) {
10186       {
10187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10188       };
10189     } catch (std::exception& e) {
10190       {
10191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10192       };
10193     } catch (Dali::DaliException e) {
10194       {
10195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10196       };
10197     } catch (...) {
10198       {
10199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10200       };
10201     }
10202   }
10203
10204   jresult = result;
10205   return jresult;
10206 }
10207
10208
10209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10210   unsigned int jresult ;
10211   Dali::Radian arg1 ;
10212   Dali::Radian arg2 ;
10213   Dali::Radian *argp1 ;
10214   Dali::Radian *argp2 ;
10215   bool result;
10216
10217   argp1 = (Dali::Radian *)jarg1;
10218   if (!argp1) {
10219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10220     return 0;
10221   }
10222   arg1 = *argp1;
10223   argp2 = (Dali::Radian *)jarg2;
10224   if (!argp2) {
10225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10226     return 0;
10227   }
10228   arg2 = *argp2;
10229   {
10230     try {
10231       result = (bool)Dali::operator !=(arg1,arg2);
10232     } catch (std::out_of_range& e) {
10233       {
10234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (std::exception& e) {
10237       {
10238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10239       };
10240     } catch (Dali::DaliException e) {
10241       {
10242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10243       };
10244     } catch (...) {
10245       {
10246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10247       };
10248     }
10249   }
10250
10251   jresult = result;
10252   return jresult;
10253 }
10254
10255
10256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10257   unsigned int jresult ;
10258   Dali::Radian arg1 ;
10259   Dali::Degree arg2 ;
10260   Dali::Radian *argp1 ;
10261   Dali::Degree *argp2 ;
10262   bool result;
10263
10264   argp1 = (Dali::Radian *)jarg1;
10265   if (!argp1) {
10266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10267     return 0;
10268   }
10269   arg1 = *argp1;
10270   argp2 = (Dali::Degree *)jarg2;
10271   if (!argp2) {
10272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10273     return 0;
10274   }
10275   arg2 = *argp2;
10276   {
10277     try {
10278       result = (bool)Dali::operator ==(arg1,arg2);
10279     } catch (std::out_of_range& e) {
10280       {
10281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (std::exception& e) {
10284       {
10285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10286       };
10287     } catch (Dali::DaliException e) {
10288       {
10289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10290       };
10291     } catch (...) {
10292       {
10293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10294       };
10295     }
10296   }
10297
10298   jresult = result;
10299   return jresult;
10300 }
10301
10302
10303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10304   unsigned int jresult ;
10305   Dali::Radian arg1 ;
10306   Dali::Degree arg2 ;
10307   Dali::Radian *argp1 ;
10308   Dali::Degree *argp2 ;
10309   bool result;
10310
10311   argp1 = (Dali::Radian *)jarg1;
10312   if (!argp1) {
10313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10314     return 0;
10315   }
10316   arg1 = *argp1;
10317   argp2 = (Dali::Degree *)jarg2;
10318   if (!argp2) {
10319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10320     return 0;
10321   }
10322   arg2 = *argp2;
10323   {
10324     try {
10325       result = (bool)Dali::operator !=(arg1,arg2);
10326     } catch (std::out_of_range& e) {
10327       {
10328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (std::exception& e) {
10331       {
10332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10333       };
10334     } catch (Dali::DaliException e) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10337       };
10338     } catch (...) {
10339       {
10340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10341       };
10342     }
10343   }
10344
10345   jresult = result;
10346   return jresult;
10347 }
10348
10349
10350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10351   unsigned int jresult ;
10352   Dali::Degree arg1 ;
10353   Dali::Radian arg2 ;
10354   Dali::Degree *argp1 ;
10355   Dali::Radian *argp2 ;
10356   bool result;
10357
10358   argp1 = (Dali::Degree *)jarg1;
10359   if (!argp1) {
10360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10361     return 0;
10362   }
10363   arg1 = *argp1;
10364   argp2 = (Dali::Radian *)jarg2;
10365   if (!argp2) {
10366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10367     return 0;
10368   }
10369   arg2 = *argp2;
10370   {
10371     try {
10372       result = (bool)Dali::operator ==(arg1,arg2);
10373     } catch (std::out_of_range& e) {
10374       {
10375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (std::exception& e) {
10378       {
10379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10380       };
10381     } catch (Dali::DaliException e) {
10382       {
10383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10384       };
10385     } catch (...) {
10386       {
10387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10388       };
10389     }
10390   }
10391
10392   jresult = result;
10393   return jresult;
10394 }
10395
10396
10397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10398   unsigned int jresult ;
10399   Dali::Degree arg1 ;
10400   Dali::Radian arg2 ;
10401   Dali::Degree *argp1 ;
10402   Dali::Radian *argp2 ;
10403   bool result;
10404
10405   argp1 = (Dali::Degree *)jarg1;
10406   if (!argp1) {
10407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10408     return 0;
10409   }
10410   arg1 = *argp1;
10411   argp2 = (Dali::Radian *)jarg2;
10412   if (!argp2) {
10413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10414     return 0;
10415   }
10416   arg2 = *argp2;
10417   {
10418     try {
10419       result = (bool)Dali::operator !=(arg1,arg2);
10420     } catch (std::out_of_range& e) {
10421       {
10422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (std::exception& e) {
10425       {
10426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10427       };
10428     } catch (Dali::DaliException e) {
10429       {
10430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10431       };
10432     } catch (...) {
10433       {
10434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10435       };
10436     }
10437   }
10438
10439   jresult = result;
10440   return jresult;
10441 }
10442
10443
10444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10445   unsigned int jresult ;
10446   Dali::Radian arg1 ;
10447   Dali::Radian arg2 ;
10448   Dali::Radian *argp1 ;
10449   Dali::Radian *argp2 ;
10450   bool result;
10451
10452   argp1 = (Dali::Radian *)jarg1;
10453   if (!argp1) {
10454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10455     return 0;
10456   }
10457   arg1 = *argp1;
10458   argp2 = (Dali::Radian *)jarg2;
10459   if (!argp2) {
10460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10461     return 0;
10462   }
10463   arg2 = *argp2;
10464   {
10465     try {
10466       result = (bool)Dali::operator >(arg1,arg2);
10467     } catch (std::out_of_range& e) {
10468       {
10469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10470       };
10471     } catch (std::exception& e) {
10472       {
10473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10474       };
10475     } catch (Dali::DaliException e) {
10476       {
10477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10478       };
10479     } catch (...) {
10480       {
10481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10482       };
10483     }
10484   }
10485
10486   jresult = result;
10487   return jresult;
10488 }
10489
10490
10491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10492   unsigned int jresult ;
10493   Dali::Radian arg1 ;
10494   Dali::Degree arg2 ;
10495   Dali::Radian *argp1 ;
10496   Dali::Degree *argp2 ;
10497   bool result;
10498
10499   argp1 = (Dali::Radian *)jarg1;
10500   if (!argp1) {
10501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10502     return 0;
10503   }
10504   arg1 = *argp1;
10505   argp2 = (Dali::Degree *)jarg2;
10506   if (!argp2) {
10507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10508     return 0;
10509   }
10510   arg2 = *argp2;
10511   {
10512     try {
10513       result = (bool)Dali::operator >(arg1,arg2);
10514     } catch (std::out_of_range& e) {
10515       {
10516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (std::exception& e) {
10519       {
10520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10521       };
10522     } catch (Dali::DaliException e) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10525       };
10526     } catch (...) {
10527       {
10528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10529       };
10530     }
10531   }
10532
10533   jresult = result;
10534   return jresult;
10535 }
10536
10537
10538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10539   unsigned int jresult ;
10540   Dali::Degree arg1 ;
10541   Dali::Radian arg2 ;
10542   Dali::Degree *argp1 ;
10543   Dali::Radian *argp2 ;
10544   bool result;
10545
10546   argp1 = (Dali::Degree *)jarg1;
10547   if (!argp1) {
10548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10549     return 0;
10550   }
10551   arg1 = *argp1;
10552   argp2 = (Dali::Radian *)jarg2;
10553   if (!argp2) {
10554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10555     return 0;
10556   }
10557   arg2 = *argp2;
10558   {
10559     try {
10560       result = (bool)Dali::operator >(arg1,arg2);
10561     } catch (std::out_of_range& e) {
10562       {
10563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10564       };
10565     } catch (std::exception& e) {
10566       {
10567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10568       };
10569     } catch (Dali::DaliException e) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10572       };
10573     } catch (...) {
10574       {
10575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10576       };
10577     }
10578   }
10579
10580   jresult = result;
10581   return jresult;
10582 }
10583
10584
10585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10586   unsigned int jresult ;
10587   Dali::Radian arg1 ;
10588   Dali::Radian arg2 ;
10589   Dali::Radian *argp1 ;
10590   Dali::Radian *argp2 ;
10591   bool result;
10592
10593   argp1 = (Dali::Radian *)jarg1;
10594   if (!argp1) {
10595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10596     return 0;
10597   }
10598   arg1 = *argp1;
10599   argp2 = (Dali::Radian *)jarg2;
10600   if (!argp2) {
10601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10602     return 0;
10603   }
10604   arg2 = *argp2;
10605   {
10606     try {
10607       result = (bool)Dali::operator <(arg1,arg2);
10608     } catch (std::out_of_range& e) {
10609       {
10610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10611       };
10612     } catch (std::exception& e) {
10613       {
10614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10615       };
10616     } catch (Dali::DaliException e) {
10617       {
10618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10619       };
10620     } catch (...) {
10621       {
10622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10623       };
10624     }
10625   }
10626
10627   jresult = result;
10628   return jresult;
10629 }
10630
10631
10632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10633   unsigned int jresult ;
10634   Dali::Radian arg1 ;
10635   Dali::Degree arg2 ;
10636   Dali::Radian *argp1 ;
10637   Dali::Degree *argp2 ;
10638   bool result;
10639
10640   argp1 = (Dali::Radian *)jarg1;
10641   if (!argp1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10643     return 0;
10644   }
10645   arg1 = *argp1;
10646   argp2 = (Dali::Degree *)jarg2;
10647   if (!argp2) {
10648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10649     return 0;
10650   }
10651   arg2 = *argp2;
10652   {
10653     try {
10654       result = (bool)Dali::operator <(arg1,arg2);
10655     } catch (std::out_of_range& e) {
10656       {
10657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (std::exception& e) {
10660       {
10661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10662       };
10663     } catch (Dali::DaliException e) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10666       };
10667     } catch (...) {
10668       {
10669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10670       };
10671     }
10672   }
10673
10674   jresult = result;
10675   return jresult;
10676 }
10677
10678
10679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10680   unsigned int jresult ;
10681   Dali::Degree arg1 ;
10682   Dali::Radian arg2 ;
10683   Dali::Degree *argp1 ;
10684   Dali::Radian *argp2 ;
10685   bool result;
10686
10687   argp1 = (Dali::Degree *)jarg1;
10688   if (!argp1) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10690     return 0;
10691   }
10692   arg1 = *argp1;
10693   argp2 = (Dali::Radian *)jarg2;
10694   if (!argp2) {
10695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10696     return 0;
10697   }
10698   arg2 = *argp2;
10699   {
10700     try {
10701       result = (bool)Dali::operator <(arg1,arg2);
10702     } catch (std::out_of_range& e) {
10703       {
10704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10705       };
10706     } catch (std::exception& e) {
10707       {
10708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10709       };
10710     } catch (Dali::DaliException e) {
10711       {
10712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10713       };
10714     } catch (...) {
10715       {
10716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10717       };
10718     }
10719   }
10720
10721   jresult = result;
10722   return jresult;
10723 }
10724
10725
10726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10727   void * jresult ;
10728   Dali::Radian arg1 ;
10729   float arg2 ;
10730   Dali::Radian *argp1 ;
10731   Dali::Radian result;
10732
10733   argp1 = (Dali::Radian *)jarg1;
10734   if (!argp1) {
10735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10736     return 0;
10737   }
10738   arg1 = *argp1;
10739   arg2 = (float)jarg2;
10740   {
10741     try {
10742       result = Dali::operator *(arg1,arg2);
10743     } catch (std::out_of_range& e) {
10744       {
10745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10746       };
10747     } catch (std::exception& e) {
10748       {
10749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10750       };
10751     } catch (Dali::DaliException e) {
10752       {
10753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10754       };
10755     } catch (...) {
10756       {
10757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10758       };
10759     }
10760   }
10761
10762   jresult = new Dali::Radian((const Dali::Radian &)result);
10763   return jresult;
10764 }
10765
10766
10767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10768   void * jresult ;
10769   Dali::Radian arg1 ;
10770   Dali::Radian *argp1 ;
10771   Dali::Radian result;
10772
10773   argp1 = (Dali::Radian *)jarg1;
10774   if (!argp1) {
10775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10776     return 0;
10777   }
10778   arg1 = *argp1;
10779   {
10780     try {
10781       result = Dali::operator -(arg1);
10782     } catch (std::out_of_range& e) {
10783       {
10784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10785       };
10786     } catch (std::exception& e) {
10787       {
10788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10789       };
10790     } catch (Dali::DaliException e) {
10791       {
10792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10793       };
10794     } catch (...) {
10795       {
10796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10797       };
10798     }
10799   }
10800
10801   jresult = new Dali::Radian((const Dali::Radian &)result);
10802   return jresult;
10803 }
10804
10805
10806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10807   void * jresult ;
10808   Dali::Radian arg1 ;
10809   float arg2 ;
10810   float arg3 ;
10811   Dali::Radian *argp1 ;
10812   Dali::Radian result;
10813
10814   argp1 = (Dali::Radian *)jarg1;
10815   if (!argp1) {
10816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10817     return 0;
10818   }
10819   arg1 = *argp1;
10820   arg2 = (float)jarg2;
10821   arg3 = (float)jarg3;
10822   {
10823     try {
10824       result = Dali::Clamp(arg1,arg2,arg3);
10825     } catch (std::out_of_range& e) {
10826       {
10827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10828       };
10829     } catch (std::exception& e) {
10830       {
10831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (Dali::DaliException e) {
10834       {
10835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10836       };
10837     } catch (...) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10840       };
10841     }
10842   }
10843
10844   jresult = new Dali::Radian((const Dali::Radian &)result);
10845   return jresult;
10846 }
10847
10848
10849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10850   void * jresult ;
10851   Dali::Quaternion *result = 0 ;
10852
10853   {
10854     try {
10855       result = (Dali::Quaternion *)new Dali::Quaternion();
10856     } catch (std::out_of_range& e) {
10857       {
10858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10859       };
10860     } catch (std::exception& e) {
10861       {
10862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10863       };
10864     } catch (Dali::DaliException e) {
10865       {
10866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10867       };
10868     } catch (...) {
10869       {
10870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10871       };
10872     }
10873   }
10874
10875   jresult = (void *)result;
10876   return jresult;
10877 }
10878
10879
10880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10881   void * jresult ;
10882   Dali::Radian arg1 ;
10883   Dali::Vector3 *arg2 = 0 ;
10884   Dali::Radian *argp1 ;
10885   Dali::Quaternion *result = 0 ;
10886
10887   argp1 = (Dali::Radian *)jarg1;
10888   if (!argp1) {
10889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10890     return 0;
10891   }
10892   arg1 = *argp1;
10893   arg2 = (Dali::Vector3 *)jarg2;
10894   if (!arg2) {
10895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10896     return 0;
10897   }
10898   {
10899     try {
10900       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10901     } catch (std::out_of_range& e) {
10902       {
10903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (std::exception& e) {
10906       {
10907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10908       };
10909     } catch (Dali::DaliException e) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10912       };
10913     } catch (...) {
10914       {
10915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10916       };
10917     }
10918   }
10919
10920   jresult = (void *)result;
10921   return jresult;
10922 }
10923
10924
10925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10926   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10927
10928   arg1 = (Dali::Quaternion *)jarg1;
10929   {
10930     try {
10931       delete arg1;
10932     } catch (std::out_of_range& e) {
10933       {
10934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10935       };
10936     } catch (std::exception& e) {
10937       {
10938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10939       };
10940     } catch (Dali::DaliException e) {
10941       {
10942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10943       };
10944     } catch (...) {
10945       {
10946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10947       };
10948     }
10949   }
10950
10951 }
10952
10953
10954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10955   void * jresult ;
10956   Dali::Quaternion *result = 0 ;
10957
10958   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10959   jresult = (void *)result;
10960   return jresult;
10961 }
10962
10963
10964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10965   unsigned int jresult ;
10966   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10967   bool result;
10968
10969   arg1 = (Dali::Quaternion *)jarg1;
10970   {
10971     try {
10972       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10973     } catch (std::out_of_range& e) {
10974       {
10975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10976       };
10977     } catch (std::exception& e) {
10978       {
10979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10980       };
10981     } catch (Dali::DaliException e) {
10982       {
10983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10984       };
10985     } catch (...) {
10986       {
10987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10988       };
10989     }
10990   }
10991
10992   jresult = result;
10993   return jresult;
10994 }
10995
10996
10997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10998   unsigned int jresult ;
10999   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11000   Dali::Vector3 *arg2 = 0 ;
11001   Dali::Radian *arg3 = 0 ;
11002   bool result;
11003
11004   arg1 = (Dali::Quaternion *)jarg1;
11005   arg2 = (Dali::Vector3 *)jarg2;
11006   if (!arg2) {
11007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11008     return 0;
11009   }
11010   arg3 = (Dali::Radian *)jarg3;
11011   if (!arg3) {
11012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11013     return 0;
11014   }
11015   {
11016     try {
11017       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11018     } catch (std::out_of_range& e) {
11019       {
11020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (std::exception& e) {
11023       {
11024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11025       };
11026     } catch (Dali::DaliException e) {
11027       {
11028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11029       };
11030     } catch (...) {
11031       {
11032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11033       };
11034     }
11035   }
11036
11037   jresult = result;
11038   return jresult;
11039 }
11040
11041
11042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11043   void * jresult ;
11044   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11045   Dali::Quaternion *arg2 = 0 ;
11046   Dali::Quaternion result;
11047
11048   arg1 = (Dali::Quaternion *)jarg1;
11049   arg2 = (Dali::Quaternion *)jarg2;
11050   if (!arg2) {
11051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11052     return 0;
11053   }
11054   {
11055     try {
11056       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11057     } catch (std::out_of_range& e) {
11058       {
11059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11060       };
11061     } catch (std::exception& e) {
11062       {
11063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11064       };
11065     } catch (Dali::DaliException e) {
11066       {
11067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11068       };
11069     } catch (...) {
11070       {
11071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11072       };
11073     }
11074   }
11075
11076   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11077   return jresult;
11078 }
11079
11080
11081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11082   void * jresult ;
11083   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11084   Dali::Quaternion *arg2 = 0 ;
11085   Dali::Quaternion result;
11086
11087   arg1 = (Dali::Quaternion *)jarg1;
11088   arg2 = (Dali::Quaternion *)jarg2;
11089   if (!arg2) {
11090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11091     return 0;
11092   }
11093   {
11094     try {
11095       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11096     } catch (std::out_of_range& e) {
11097       {
11098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11099       };
11100     } catch (std::exception& e) {
11101       {
11102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11103       };
11104     } catch (Dali::DaliException e) {
11105       {
11106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11107       };
11108     } catch (...) {
11109       {
11110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11111       };
11112     }
11113   }
11114
11115   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11116   return jresult;
11117 }
11118
11119
11120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11121   void * jresult ;
11122   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11123   Dali::Quaternion *arg2 = 0 ;
11124   Dali::Quaternion result;
11125
11126   arg1 = (Dali::Quaternion *)jarg1;
11127   arg2 = (Dali::Quaternion *)jarg2;
11128   if (!arg2) {
11129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11130     return 0;
11131   }
11132   {
11133     try {
11134       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11135     } catch (std::out_of_range& e) {
11136       {
11137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11138       };
11139     } catch (std::exception& e) {
11140       {
11141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11142       };
11143     } catch (Dali::DaliException e) {
11144       {
11145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11146       };
11147     } catch (...) {
11148       {
11149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11150       };
11151     }
11152   }
11153
11154   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11155   return jresult;
11156 }
11157
11158
11159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11160   void * jresult ;
11161   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11162   Dali::Vector3 *arg2 = 0 ;
11163   Dali::Vector3 result;
11164
11165   arg1 = (Dali::Quaternion *)jarg1;
11166   arg2 = (Dali::Vector3 *)jarg2;
11167   if (!arg2) {
11168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11169     return 0;
11170   }
11171   {
11172     try {
11173       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11174     } catch (std::out_of_range& e) {
11175       {
11176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11177       };
11178     } catch (std::exception& e) {
11179       {
11180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11181       };
11182     } catch (Dali::DaliException e) {
11183       {
11184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11185       };
11186     } catch (...) {
11187       {
11188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11189       };
11190     }
11191   }
11192
11193   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11194   return jresult;
11195 }
11196
11197
11198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11199   void * jresult ;
11200   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11201   Dali::Quaternion *arg2 = 0 ;
11202   Dali::Quaternion result;
11203
11204   arg1 = (Dali::Quaternion *)jarg1;
11205   arg2 = (Dali::Quaternion *)jarg2;
11206   if (!arg2) {
11207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11208     return 0;
11209   }
11210   {
11211     try {
11212       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11213     } catch (std::out_of_range& e) {
11214       {
11215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11216       };
11217     } catch (std::exception& e) {
11218       {
11219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11220       };
11221     } catch (Dali::DaliException e) {
11222       {
11223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11224       };
11225     } catch (...) {
11226       {
11227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11228       };
11229     }
11230   }
11231
11232   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11233   return jresult;
11234 }
11235
11236
11237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11238   void * jresult ;
11239   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11240   float arg2 ;
11241   Dali::Quaternion result;
11242
11243   arg1 = (Dali::Quaternion *)jarg1;
11244   arg2 = (float)jarg2;
11245   {
11246     try {
11247       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11248     } catch (std::out_of_range& e) {
11249       {
11250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11251       };
11252     } catch (std::exception& e) {
11253       {
11254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11255       };
11256     } catch (Dali::DaliException e) {
11257       {
11258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11259       };
11260     } catch (...) {
11261       {
11262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11263       };
11264     }
11265   }
11266
11267   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11268   return jresult;
11269 }
11270
11271
11272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11273   void * jresult ;
11274   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11275   float arg2 ;
11276   Dali::Quaternion result;
11277
11278   arg1 = (Dali::Quaternion *)jarg1;
11279   arg2 = (float)jarg2;
11280   {
11281     try {
11282       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11283     } catch (std::out_of_range& e) {
11284       {
11285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11286       };
11287     } catch (std::exception& e) {
11288       {
11289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11290       };
11291     } catch (Dali::DaliException e) {
11292       {
11293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11294       };
11295     } catch (...) {
11296       {
11297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11298       };
11299     }
11300   }
11301
11302   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11303   return jresult;
11304 }
11305
11306
11307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11308   void * jresult ;
11309   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11310   Dali::Quaternion result;
11311
11312   arg1 = (Dali::Quaternion *)jarg1;
11313   {
11314     try {
11315       result = ((Dali::Quaternion const *)arg1)->operator -();
11316     } catch (std::out_of_range& e) {
11317       {
11318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11319       };
11320     } catch (std::exception& e) {
11321       {
11322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11323       };
11324     } catch (Dali::DaliException e) {
11325       {
11326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11327       };
11328     } catch (...) {
11329       {
11330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11331       };
11332     }
11333   }
11334
11335   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11336   return jresult;
11337 }
11338
11339
11340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11341   void * jresult ;
11342   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11343   Dali::Quaternion *arg2 = 0 ;
11344   Dali::Quaternion *result = 0 ;
11345
11346   arg1 = (Dali::Quaternion *)jarg1;
11347   arg2 = (Dali::Quaternion *)jarg2;
11348   if (!arg2) {
11349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11350     return 0;
11351   }
11352   {
11353     try {
11354       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11355     } catch (std::out_of_range& e) {
11356       {
11357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11358       };
11359     } catch (std::exception& e) {
11360       {
11361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11362       };
11363     } catch (Dali::DaliException e) {
11364       {
11365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11366       };
11367     } catch (...) {
11368       {
11369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11370       };
11371     }
11372   }
11373
11374   jresult = (void *)result;
11375   return jresult;
11376 }
11377
11378
11379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11380   void * jresult ;
11381   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11382   Dali::Quaternion *arg2 = 0 ;
11383   Dali::Quaternion *result = 0 ;
11384
11385   arg1 = (Dali::Quaternion *)jarg1;
11386   arg2 = (Dali::Quaternion *)jarg2;
11387   if (!arg2) {
11388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11389     return 0;
11390   }
11391   {
11392     try {
11393       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11394     } catch (std::out_of_range& e) {
11395       {
11396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11397       };
11398     } catch (std::exception& e) {
11399       {
11400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11401       };
11402     } catch (Dali::DaliException e) {
11403       {
11404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11405       };
11406     } catch (...) {
11407       {
11408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11409       };
11410     }
11411   }
11412
11413   jresult = (void *)result;
11414   return jresult;
11415 }
11416
11417
11418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11419   void * jresult ;
11420   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11421   Dali::Quaternion *arg2 = 0 ;
11422   Dali::Quaternion *result = 0 ;
11423
11424   arg1 = (Dali::Quaternion *)jarg1;
11425   arg2 = (Dali::Quaternion *)jarg2;
11426   if (!arg2) {
11427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11428     return 0;
11429   }
11430   {
11431     try {
11432       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11433     } catch (std::out_of_range& e) {
11434       {
11435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11436       };
11437     } catch (std::exception& e) {
11438       {
11439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11440       };
11441     } catch (Dali::DaliException e) {
11442       {
11443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11444       };
11445     } catch (...) {
11446       {
11447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11448       };
11449     }
11450   }
11451
11452   jresult = (void *)result;
11453   return jresult;
11454 }
11455
11456
11457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11458   void * jresult ;
11459   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11460   float arg2 ;
11461   Dali::Quaternion *result = 0 ;
11462
11463   arg1 = (Dali::Quaternion *)jarg1;
11464   arg2 = (float)jarg2;
11465   {
11466     try {
11467       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11468     } catch (std::out_of_range& e) {
11469       {
11470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11471       };
11472     } catch (std::exception& e) {
11473       {
11474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11475       };
11476     } catch (Dali::DaliException e) {
11477       {
11478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11479       };
11480     } catch (...) {
11481       {
11482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11483       };
11484     }
11485   }
11486
11487   jresult = (void *)result;
11488   return jresult;
11489 }
11490
11491
11492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11493   void * jresult ;
11494   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11495   float arg2 ;
11496   Dali::Quaternion *result = 0 ;
11497
11498   arg1 = (Dali::Quaternion *)jarg1;
11499   arg2 = (float)jarg2;
11500   {
11501     try {
11502       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11503     } catch (std::out_of_range& e) {
11504       {
11505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11506       };
11507     } catch (std::exception& e) {
11508       {
11509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11510       };
11511     } catch (Dali::DaliException e) {
11512       {
11513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11514       };
11515     } catch (...) {
11516       {
11517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11518       };
11519     }
11520   }
11521
11522   jresult = (void *)result;
11523   return jresult;
11524 }
11525
11526
11527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11528   unsigned int jresult ;
11529   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11530   Dali::Quaternion *arg2 = 0 ;
11531   bool result;
11532
11533   arg1 = (Dali::Quaternion *)jarg1;
11534   arg2 = (Dali::Quaternion *)jarg2;
11535   if (!arg2) {
11536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11537     return 0;
11538   }
11539   {
11540     try {
11541       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11542     } catch (std::out_of_range& e) {
11543       {
11544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11545       };
11546     } catch (std::exception& e) {
11547       {
11548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11549       };
11550     } catch (Dali::DaliException e) {
11551       {
11552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11553       };
11554     } catch (...) {
11555       {
11556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11557       };
11558     }
11559   }
11560
11561   jresult = result;
11562   return jresult;
11563 }
11564
11565
11566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11567   unsigned int jresult ;
11568   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11569   Dali::Quaternion *arg2 = 0 ;
11570   bool result;
11571
11572   arg1 = (Dali::Quaternion *)jarg1;
11573   arg2 = (Dali::Quaternion *)jarg2;
11574   if (!arg2) {
11575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11576     return 0;
11577   }
11578   {
11579     try {
11580       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11581     } catch (std::out_of_range& e) {
11582       {
11583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11584       };
11585     } catch (std::exception& e) {
11586       {
11587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11588       };
11589     } catch (Dali::DaliException e) {
11590       {
11591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11592       };
11593     } catch (...) {
11594       {
11595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11596       };
11597     }
11598   }
11599
11600   jresult = result;
11601   return jresult;
11602 }
11603
11604
11605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11606   float jresult ;
11607   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11608   float result;
11609
11610   arg1 = (Dali::Quaternion *)jarg1;
11611   {
11612     try {
11613       result = (float)((Dali::Quaternion const *)arg1)->Length();
11614     } catch (std::out_of_range& e) {
11615       {
11616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11617       };
11618     } catch (std::exception& e) {
11619       {
11620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11621       };
11622     } catch (Dali::DaliException e) {
11623       {
11624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11625       };
11626     } catch (...) {
11627       {
11628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11629       };
11630     }
11631   }
11632
11633   jresult = result;
11634   return jresult;
11635 }
11636
11637
11638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11639   float jresult ;
11640   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11641   float result;
11642
11643   arg1 = (Dali::Quaternion *)jarg1;
11644   {
11645     try {
11646       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11647     } catch (std::out_of_range& e) {
11648       {
11649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11650       };
11651     } catch (std::exception& e) {
11652       {
11653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11654       };
11655     } catch (Dali::DaliException e) {
11656       {
11657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11658       };
11659     } catch (...) {
11660       {
11661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11662       };
11663     }
11664   }
11665
11666   jresult = result;
11667   return jresult;
11668 }
11669
11670
11671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11672   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11673
11674   arg1 = (Dali::Quaternion *)jarg1;
11675   {
11676     try {
11677       (arg1)->Normalize();
11678     } catch (std::out_of_range& e) {
11679       {
11680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11681       };
11682     } catch (std::exception& e) {
11683       {
11684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11685       };
11686     } catch (Dali::DaliException e) {
11687       {
11688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11689       };
11690     } catch (...) {
11691       {
11692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11693       };
11694     }
11695   }
11696
11697 }
11698
11699
11700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11701   void * jresult ;
11702   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11703   Dali::Quaternion result;
11704
11705   arg1 = (Dali::Quaternion *)jarg1;
11706   {
11707     try {
11708       result = ((Dali::Quaternion const *)arg1)->Normalized();
11709     } catch (std::out_of_range& e) {
11710       {
11711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11712       };
11713     } catch (std::exception& e) {
11714       {
11715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11716       };
11717     } catch (Dali::DaliException e) {
11718       {
11719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11720       };
11721     } catch (...) {
11722       {
11723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11724       };
11725     }
11726   }
11727
11728   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11729   return jresult;
11730 }
11731
11732
11733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11734   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11735
11736   arg1 = (Dali::Quaternion *)jarg1;
11737   {
11738     try {
11739       (arg1)->Conjugate();
11740     } catch (std::out_of_range& e) {
11741       {
11742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11743       };
11744     } catch (std::exception& e) {
11745       {
11746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11747       };
11748     } catch (Dali::DaliException e) {
11749       {
11750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11751       };
11752     } catch (...) {
11753       {
11754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11755       };
11756     }
11757   }
11758
11759 }
11760
11761
11762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11763   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11764
11765   arg1 = (Dali::Quaternion *)jarg1;
11766   {
11767     try {
11768       (arg1)->Invert();
11769     } catch (std::out_of_range& e) {
11770       {
11771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11772       };
11773     } catch (std::exception& e) {
11774       {
11775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11776       };
11777     } catch (Dali::DaliException e) {
11778       {
11779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11780       };
11781     } catch (...) {
11782       {
11783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11784       };
11785     }
11786   }
11787
11788 }
11789
11790
11791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11792   void * jresult ;
11793   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11794   Dali::Quaternion result;
11795
11796   arg1 = (Dali::Quaternion *)jarg1;
11797   {
11798     try {
11799       result = ((Dali::Quaternion const *)arg1)->Log();
11800     } catch (std::out_of_range& e) {
11801       {
11802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11803       };
11804     } catch (std::exception& e) {
11805       {
11806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11807       };
11808     } catch (Dali::DaliException e) {
11809       {
11810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11811       };
11812     } catch (...) {
11813       {
11814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11815       };
11816     }
11817   }
11818
11819   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11820   return jresult;
11821 }
11822
11823
11824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11825   void * jresult ;
11826   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11827   Dali::Quaternion result;
11828
11829   arg1 = (Dali::Quaternion *)jarg1;
11830   {
11831     try {
11832       result = ((Dali::Quaternion const *)arg1)->Exp();
11833     } catch (std::out_of_range& e) {
11834       {
11835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11836       };
11837     } catch (std::exception& e) {
11838       {
11839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11840       };
11841     } catch (Dali::DaliException e) {
11842       {
11843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11844       };
11845     } catch (...) {
11846       {
11847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11848       };
11849     }
11850   }
11851
11852   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11853   return jresult;
11854 }
11855
11856
11857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11858   float jresult ;
11859   Dali::Quaternion *arg1 = 0 ;
11860   Dali::Quaternion *arg2 = 0 ;
11861   float result;
11862
11863   arg1 = (Dali::Quaternion *)jarg1;
11864   if (!arg1) {
11865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11866     return 0;
11867   }
11868   arg2 = (Dali::Quaternion *)jarg2;
11869   if (!arg2) {
11870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11871     return 0;
11872   }
11873   {
11874     try {
11875       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11876     } catch (std::out_of_range& e) {
11877       {
11878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11879       };
11880     } catch (std::exception& e) {
11881       {
11882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11883       };
11884     } catch (Dali::DaliException e) {
11885       {
11886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11887       };
11888     } catch (...) {
11889       {
11890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11891       };
11892     }
11893   }
11894
11895   jresult = result;
11896   return jresult;
11897 }
11898
11899
11900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11901   void * jresult ;
11902   Dali::Quaternion *arg1 = 0 ;
11903   Dali::Quaternion *arg2 = 0 ;
11904   float arg3 ;
11905   Dali::Quaternion result;
11906
11907   arg1 = (Dali::Quaternion *)jarg1;
11908   if (!arg1) {
11909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11910     return 0;
11911   }
11912   arg2 = (Dali::Quaternion *)jarg2;
11913   if (!arg2) {
11914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11915     return 0;
11916   }
11917   arg3 = (float)jarg3;
11918   {
11919     try {
11920       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11921     } catch (std::out_of_range& e) {
11922       {
11923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (std::exception& e) {
11926       {
11927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11928       };
11929     } catch (Dali::DaliException e) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11932       };
11933     } catch (...) {
11934       {
11935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11936       };
11937     }
11938   }
11939
11940   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11941   return jresult;
11942 }
11943
11944
11945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11946   void * jresult ;
11947   Dali::Quaternion *arg1 = 0 ;
11948   Dali::Quaternion *arg2 = 0 ;
11949   float arg3 ;
11950   Dali::Quaternion result;
11951
11952   arg1 = (Dali::Quaternion *)jarg1;
11953   if (!arg1) {
11954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11955     return 0;
11956   }
11957   arg2 = (Dali::Quaternion *)jarg2;
11958   if (!arg2) {
11959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11960     return 0;
11961   }
11962   arg3 = (float)jarg3;
11963   {
11964     try {
11965       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11966     } catch (std::out_of_range& e) {
11967       {
11968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (std::exception& e) {
11971       {
11972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11973       };
11974     } catch (Dali::DaliException e) {
11975       {
11976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11977       };
11978     } catch (...) {
11979       {
11980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11981       };
11982     }
11983   }
11984
11985   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11986   return jresult;
11987 }
11988
11989
11990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
11991   void * jresult ;
11992   Dali::Quaternion *arg1 = 0 ;
11993   Dali::Quaternion *arg2 = 0 ;
11994   float arg3 ;
11995   Dali::Quaternion result;
11996
11997   arg1 = (Dali::Quaternion *)jarg1;
11998   if (!arg1) {
11999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12000     return 0;
12001   }
12002   arg2 = (Dali::Quaternion *)jarg2;
12003   if (!arg2) {
12004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12005     return 0;
12006   }
12007   arg3 = (float)jarg3;
12008   {
12009     try {
12010       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12011     } catch (std::out_of_range& e) {
12012       {
12013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12014       };
12015     } catch (std::exception& e) {
12016       {
12017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12018       };
12019     } catch (Dali::DaliException e) {
12020       {
12021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12022       };
12023     } catch (...) {
12024       {
12025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12026       };
12027     }
12028   }
12029
12030   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12031   return jresult;
12032 }
12033
12034
12035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12036   void * jresult ;
12037   Dali::Quaternion *arg1 = 0 ;
12038   Dali::Quaternion *arg2 = 0 ;
12039   Dali::Quaternion *arg3 = 0 ;
12040   Dali::Quaternion *arg4 = 0 ;
12041   float arg5 ;
12042   Dali::Quaternion result;
12043
12044   arg1 = (Dali::Quaternion *)jarg1;
12045   if (!arg1) {
12046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12047     return 0;
12048   }
12049   arg2 = (Dali::Quaternion *)jarg2;
12050   if (!arg2) {
12051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12052     return 0;
12053   }
12054   arg3 = (Dali::Quaternion *)jarg3;
12055   if (!arg3) {
12056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12057     return 0;
12058   }
12059   arg4 = (Dali::Quaternion *)jarg4;
12060   if (!arg4) {
12061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12062     return 0;
12063   }
12064   arg5 = (float)jarg5;
12065   {
12066     try {
12067       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12068     } catch (std::out_of_range& e) {
12069       {
12070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12071       };
12072     } catch (std::exception& e) {
12073       {
12074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12075       };
12076     } catch (Dali::DaliException e) {
12077       {
12078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12079       };
12080     } catch (...) {
12081       {
12082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12083       };
12084     }
12085   }
12086
12087   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12088   return jresult;
12089 }
12090
12091
12092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12093   float jresult ;
12094   Dali::Quaternion *arg1 = 0 ;
12095   Dali::Quaternion *arg2 = 0 ;
12096   float result;
12097
12098   arg1 = (Dali::Quaternion *)jarg1;
12099   if (!arg1) {
12100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12101     return 0;
12102   }
12103   arg2 = (Dali::Quaternion *)jarg2;
12104   if (!arg2) {
12105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12106     return 0;
12107   }
12108   {
12109     try {
12110       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12111     } catch (std::out_of_range& e) {
12112       {
12113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12114       };
12115     } catch (std::exception& e) {
12116       {
12117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (Dali::DaliException e) {
12120       {
12121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12122       };
12123     } catch (...) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12126       };
12127     }
12128   }
12129
12130   jresult = result;
12131   return jresult;
12132 }
12133
12134
12135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12136   void * jresult ;
12137   Dali::Matrix *result = 0 ;
12138
12139   {
12140     try {
12141       result = (Dali::Matrix *)new Dali::Matrix();
12142     } catch (std::out_of_range& e) {
12143       {
12144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12145       };
12146     } catch (std::exception& e) {
12147       {
12148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12149       };
12150     } catch (Dali::DaliException e) {
12151       {
12152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12153       };
12154     } catch (...) {
12155       {
12156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12157       };
12158     }
12159   }
12160
12161   jresult = (void *)result;
12162   return jresult;
12163 }
12164
12165
12166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12167   void * jresult ;
12168   bool arg1 ;
12169   Dali::Matrix *result = 0 ;
12170
12171   arg1 = jarg1 ? true : false;
12172   {
12173     try {
12174       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12175     } catch (std::out_of_range& e) {
12176       {
12177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12178       };
12179     } catch (std::exception& e) {
12180       {
12181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12182       };
12183     } catch (Dali::DaliException e) {
12184       {
12185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12186       };
12187     } catch (...) {
12188       {
12189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12190       };
12191     }
12192   }
12193
12194   jresult = (void *)result;
12195   return jresult;
12196 }
12197
12198
12199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12200   void * jresult ;
12201   float *arg1 = (float *) 0 ;
12202   Dali::Matrix *result = 0 ;
12203
12204   arg1 = jarg1;
12205   {
12206     try {
12207       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12208     } catch (std::out_of_range& e) {
12209       {
12210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12211       };
12212     } catch (std::exception& e) {
12213       {
12214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12215       };
12216     } catch (Dali::DaliException e) {
12217       {
12218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12219       };
12220     } catch (...) {
12221       {
12222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12223       };
12224     }
12225   }
12226
12227   jresult = (void *)result;
12228
12229
12230   return jresult;
12231 }
12232
12233
12234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12235   void * jresult ;
12236   Dali::Quaternion *arg1 = 0 ;
12237   Dali::Matrix *result = 0 ;
12238
12239   arg1 = (Dali::Quaternion *)jarg1;
12240   if (!arg1) {
12241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12242     return 0;
12243   }
12244   {
12245     try {
12246       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12247     } catch (std::out_of_range& e) {
12248       {
12249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12250       };
12251     } catch (std::exception& e) {
12252       {
12253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12254       };
12255     } catch (Dali::DaliException e) {
12256       {
12257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12258       };
12259     } catch (...) {
12260       {
12261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12262       };
12263     }
12264   }
12265
12266   jresult = (void *)result;
12267   return jresult;
12268 }
12269
12270
12271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12272   void * jresult ;
12273   Dali::Matrix *arg1 = 0 ;
12274   Dali::Matrix *result = 0 ;
12275
12276   arg1 = (Dali::Matrix *)jarg1;
12277   if (!arg1) {
12278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12279     return 0;
12280   }
12281   {
12282     try {
12283       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12284     } catch (std::out_of_range& e) {
12285       {
12286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12287       };
12288     } catch (std::exception& e) {
12289       {
12290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12291       };
12292     } catch (Dali::DaliException e) {
12293       {
12294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12295       };
12296     } catch (...) {
12297       {
12298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12299       };
12300     }
12301   }
12302
12303   jresult = (void *)result;
12304   return jresult;
12305 }
12306
12307
12308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12309   void * jresult ;
12310   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12311   Dali::Matrix *arg2 = 0 ;
12312   Dali::Matrix *result = 0 ;
12313
12314   arg1 = (Dali::Matrix *)jarg1;
12315   arg2 = (Dali::Matrix *)jarg2;
12316   if (!arg2) {
12317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12318     return 0;
12319   }
12320   {
12321     try {
12322       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12323     } catch (std::out_of_range& e) {
12324       {
12325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12326       };
12327     } catch (std::exception& e) {
12328       {
12329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12330       };
12331     } catch (Dali::DaliException e) {
12332       {
12333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12334       };
12335     } catch (...) {
12336       {
12337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12338       };
12339     }
12340   }
12341
12342   jresult = (void *)result;
12343   return jresult;
12344 }
12345
12346
12347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12348   void * jresult ;
12349   Dali::Matrix *result = 0 ;
12350
12351   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12352   jresult = (void *)result;
12353   return jresult;
12354 }
12355
12356
12357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12358   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12359
12360   arg1 = (Dali::Matrix *)jarg1;
12361   {
12362     try {
12363       (arg1)->SetIdentity();
12364     } catch (std::out_of_range& e) {
12365       {
12366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12367       };
12368     } catch (std::exception& e) {
12369       {
12370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12371       };
12372     } catch (Dali::DaliException e) {
12373       {
12374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12375       };
12376     } catch (...) {
12377       {
12378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12379       };
12380     }
12381   }
12382
12383 }
12384
12385
12386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12387   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12388   Dali::Vector3 *arg2 = 0 ;
12389
12390   arg1 = (Dali::Matrix *)jarg1;
12391   arg2 = (Dali::Vector3 *)jarg2;
12392   if (!arg2) {
12393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12394     return ;
12395   }
12396   {
12397     try {
12398       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12399     } catch (std::out_of_range& e) {
12400       {
12401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12402       };
12403     } catch (std::exception& e) {
12404       {
12405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12406       };
12407     } catch (Dali::DaliException e) {
12408       {
12409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12410       };
12411     } catch (...) {
12412       {
12413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12414       };
12415     }
12416   }
12417
12418 }
12419
12420
12421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12422   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12423   Dali::Matrix *arg2 = 0 ;
12424
12425   arg1 = (Dali::Matrix *)jarg1;
12426   arg2 = (Dali::Matrix *)jarg2;
12427   if (!arg2) {
12428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12429     return ;
12430   }
12431   {
12432     try {
12433       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12434     } catch (std::out_of_range& e) {
12435       {
12436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12437       };
12438     } catch (std::exception& e) {
12439       {
12440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12441       };
12442     } catch (Dali::DaliException e) {
12443       {
12444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12445       };
12446     } catch (...) {
12447       {
12448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12449       };
12450     }
12451   }
12452
12453 }
12454
12455
12456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12457   unsigned int jresult ;
12458   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12459   bool result;
12460
12461   arg1 = (Dali::Matrix *)jarg1;
12462   {
12463     try {
12464       result = (bool)(arg1)->Invert();
12465     } catch (std::out_of_range& e) {
12466       {
12467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12468       };
12469     } catch (std::exception& e) {
12470       {
12471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12472       };
12473     } catch (Dali::DaliException e) {
12474       {
12475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12476       };
12477     } catch (...) {
12478       {
12479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12480       };
12481     }
12482   }
12483
12484   jresult = result;
12485   return jresult;
12486 }
12487
12488
12489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12490   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12491
12492   arg1 = (Dali::Matrix *)jarg1;
12493   {
12494     try {
12495       (arg1)->Transpose();
12496     } catch (std::out_of_range& e) {
12497       {
12498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12499       };
12500     } catch (std::exception& e) {
12501       {
12502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12503       };
12504     } catch (Dali::DaliException e) {
12505       {
12506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12507       };
12508     } catch (...) {
12509       {
12510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12511       };
12512     }
12513   }
12514
12515 }
12516
12517
12518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12519   void * jresult ;
12520   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12521   Dali::Vector3 result;
12522
12523   arg1 = (Dali::Matrix *)jarg1;
12524   {
12525     try {
12526       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12527     } catch (std::out_of_range& e) {
12528       {
12529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12530       };
12531     } catch (std::exception& e) {
12532       {
12533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12534       };
12535     } catch (Dali::DaliException e) {
12536       {
12537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12538       };
12539     } catch (...) {
12540       {
12541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12542       };
12543     }
12544   }
12545
12546   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12547   return jresult;
12548 }
12549
12550
12551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12552   void * jresult ;
12553   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12554   Dali::Vector3 result;
12555
12556   arg1 = (Dali::Matrix *)jarg1;
12557   {
12558     try {
12559       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12560     } catch (std::out_of_range& e) {
12561       {
12562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12563       };
12564     } catch (std::exception& e) {
12565       {
12566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12567       };
12568     } catch (Dali::DaliException e) {
12569       {
12570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12571       };
12572     } catch (...) {
12573       {
12574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12575       };
12576     }
12577   }
12578
12579   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12580   return jresult;
12581 }
12582
12583
12584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12585   void * jresult ;
12586   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12587   Dali::Vector3 result;
12588
12589   arg1 = (Dali::Matrix *)jarg1;
12590   {
12591     try {
12592       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12593     } catch (std::out_of_range& e) {
12594       {
12595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12596       };
12597     } catch (std::exception& e) {
12598       {
12599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12600       };
12601     } catch (Dali::DaliException e) {
12602       {
12603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12604       };
12605     } catch (...) {
12606       {
12607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12608       };
12609     }
12610   }
12611
12612   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12613   return jresult;
12614 }
12615
12616
12617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12618   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12619   Dali::Vector3 *arg2 = 0 ;
12620
12621   arg1 = (Dali::Matrix *)jarg1;
12622   arg2 = (Dali::Vector3 *)jarg2;
12623   if (!arg2) {
12624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12625     return ;
12626   }
12627   {
12628     try {
12629       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12630     } catch (std::out_of_range& e) {
12631       {
12632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12633       };
12634     } catch (std::exception& e) {
12635       {
12636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12637       };
12638     } catch (Dali::DaliException e) {
12639       {
12640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12641       };
12642     } catch (...) {
12643       {
12644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12645       };
12646     }
12647   }
12648
12649 }
12650
12651
12652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12653   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12654   Dali::Vector3 *arg2 = 0 ;
12655
12656   arg1 = (Dali::Matrix *)jarg1;
12657   arg2 = (Dali::Vector3 *)jarg2;
12658   if (!arg2) {
12659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12660     return ;
12661   }
12662   {
12663     try {
12664       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12665     } catch (std::out_of_range& e) {
12666       {
12667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12668       };
12669     } catch (std::exception& e) {
12670       {
12671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12672       };
12673     } catch (Dali::DaliException e) {
12674       {
12675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12676       };
12677     } catch (...) {
12678       {
12679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12680       };
12681     }
12682   }
12683
12684 }
12685
12686
12687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12688   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12689   Dali::Vector3 *arg2 = 0 ;
12690
12691   arg1 = (Dali::Matrix *)jarg1;
12692   arg2 = (Dali::Vector3 *)jarg2;
12693   if (!arg2) {
12694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12695     return ;
12696   }
12697   {
12698     try {
12699       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12700     } catch (std::out_of_range& e) {
12701       {
12702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12703       };
12704     } catch (std::exception& e) {
12705       {
12706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12707       };
12708     } catch (Dali::DaliException e) {
12709       {
12710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12711       };
12712     } catch (...) {
12713       {
12714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12715       };
12716     }
12717   }
12718
12719 }
12720
12721
12722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12723   void * jresult ;
12724   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12725   Dali::Vector4 *result = 0 ;
12726
12727   arg1 = (Dali::Matrix *)jarg1;
12728   {
12729     try {
12730       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12731     } catch (std::out_of_range& e) {
12732       {
12733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12734       };
12735     } catch (std::exception& e) {
12736       {
12737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12738       };
12739     } catch (Dali::DaliException e) {
12740       {
12741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12742       };
12743     } catch (...) {
12744       {
12745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12746       };
12747     }
12748   }
12749
12750   jresult = (void *)result;
12751   return jresult;
12752 }
12753
12754
12755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12756   void * jresult ;
12757   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12758   Dali::Vector3 *result = 0 ;
12759
12760   arg1 = (Dali::Matrix *)jarg1;
12761   {
12762     try {
12763       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12764     } catch (std::out_of_range& e) {
12765       {
12766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12767       };
12768     } catch (std::exception& e) {
12769       {
12770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12771       };
12772     } catch (Dali::DaliException e) {
12773       {
12774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12775       };
12776     } catch (...) {
12777       {
12778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12779       };
12780     }
12781   }
12782
12783   jresult = (void *)result;
12784   return jresult;
12785 }
12786
12787
12788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12789   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12790   Dali::Vector4 *arg2 = 0 ;
12791
12792   arg1 = (Dali::Matrix *)jarg1;
12793   arg2 = (Dali::Vector4 *)jarg2;
12794   if (!arg2) {
12795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12796     return ;
12797   }
12798   {
12799     try {
12800       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12801     } catch (std::out_of_range& e) {
12802       {
12803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12804       };
12805     } catch (std::exception& e) {
12806       {
12807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12808       };
12809     } catch (Dali::DaliException e) {
12810       {
12811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12812       };
12813     } catch (...) {
12814       {
12815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12816       };
12817     }
12818   }
12819
12820 }
12821
12822
12823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12824   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12825   Dali::Vector3 *arg2 = 0 ;
12826
12827   arg1 = (Dali::Matrix *)jarg1;
12828   arg2 = (Dali::Vector3 *)jarg2;
12829   if (!arg2) {
12830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12831     return ;
12832   }
12833   {
12834     try {
12835       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12836     } catch (std::out_of_range& e) {
12837       {
12838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12839       };
12840     } catch (std::exception& e) {
12841       {
12842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12843       };
12844     } catch (Dali::DaliException e) {
12845       {
12846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12847       };
12848     } catch (...) {
12849       {
12850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12851       };
12852     }
12853   }
12854
12855 }
12856
12857
12858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12859   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12860
12861   arg1 = (Dali::Matrix *)jarg1;
12862   {
12863     try {
12864       (arg1)->OrthoNormalize();
12865     } catch (std::out_of_range& e) {
12866       {
12867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12868       };
12869     } catch (std::exception& e) {
12870       {
12871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12872       };
12873     } catch (Dali::DaliException e) {
12874       {
12875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12876       };
12877     } catch (...) {
12878       {
12879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12880       };
12881     }
12882   }
12883
12884 }
12885
12886
12887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12888   void * jresult ;
12889   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12890   float *result = 0 ;
12891
12892   arg1 = (Dali::Matrix *)jarg1;
12893   {
12894     try {
12895       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12896     } catch (std::out_of_range& e) {
12897       {
12898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12899       };
12900     } catch (std::exception& e) {
12901       {
12902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12903       };
12904     } catch (Dali::DaliException e) {
12905       {
12906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12907       };
12908     } catch (...) {
12909       {
12910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12911       };
12912     }
12913   }
12914
12915   jresult = (void *)result;
12916   return jresult;
12917 }
12918
12919
12920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12921   Dali::Matrix *arg1 = 0 ;
12922   Dali::Matrix *arg2 = 0 ;
12923   Dali::Matrix *arg3 = 0 ;
12924
12925   arg1 = (Dali::Matrix *)jarg1;
12926   if (!arg1) {
12927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12928     return ;
12929   }
12930   arg2 = (Dali::Matrix *)jarg2;
12931   if (!arg2) {
12932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12933     return ;
12934   }
12935   arg3 = (Dali::Matrix *)jarg3;
12936   if (!arg3) {
12937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12938     return ;
12939   }
12940   {
12941     try {
12942       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12943     } catch (std::out_of_range& e) {
12944       {
12945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12946       };
12947     } catch (std::exception& e) {
12948       {
12949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12950       };
12951     } catch (Dali::DaliException e) {
12952       {
12953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12954       };
12955     } catch (...) {
12956       {
12957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12958       };
12959     }
12960   }
12961
12962 }
12963
12964
12965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12966   Dali::Matrix *arg1 = 0 ;
12967   Dali::Matrix *arg2 = 0 ;
12968   Dali::Quaternion *arg3 = 0 ;
12969
12970   arg1 = (Dali::Matrix *)jarg1;
12971   if (!arg1) {
12972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12973     return ;
12974   }
12975   arg2 = (Dali::Matrix *)jarg2;
12976   if (!arg2) {
12977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12978     return ;
12979   }
12980   arg3 = (Dali::Quaternion *)jarg3;
12981   if (!arg3) {
12982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12983     return ;
12984   }
12985   {
12986     try {
12987       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
12988     } catch (std::out_of_range& e) {
12989       {
12990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12991       };
12992     } catch (std::exception& e) {
12993       {
12994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12995       };
12996     } catch (Dali::DaliException e) {
12997       {
12998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12999       };
13000     } catch (...) {
13001       {
13002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13003       };
13004     }
13005   }
13006
13007 }
13008
13009
13010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13011   void * jresult ;
13012   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13013   Dali::Vector4 *arg2 = 0 ;
13014   Dali::Vector4 result;
13015
13016   arg1 = (Dali::Matrix *)jarg1;
13017   arg2 = (Dali::Vector4 *)jarg2;
13018   if (!arg2) {
13019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13020     return 0;
13021   }
13022   {
13023     try {
13024       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13025     } catch (std::out_of_range& e) {
13026       {
13027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13028       };
13029     } catch (std::exception& e) {
13030       {
13031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13032       };
13033     } catch (Dali::DaliException e) {
13034       {
13035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13036       };
13037     } catch (...) {
13038       {
13039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13040       };
13041     }
13042   }
13043
13044   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13045   return jresult;
13046 }
13047
13048
13049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13050   unsigned int jresult ;
13051   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13052   Dali::Matrix *arg2 = 0 ;
13053   bool result;
13054
13055   arg1 = (Dali::Matrix *)jarg1;
13056   arg2 = (Dali::Matrix *)jarg2;
13057   if (!arg2) {
13058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13059     return 0;
13060   }
13061   {
13062     try {
13063       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13064     } catch (std::out_of_range& e) {
13065       {
13066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13067       };
13068     } catch (std::exception& e) {
13069       {
13070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13071       };
13072     } catch (Dali::DaliException e) {
13073       {
13074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13075       };
13076     } catch (...) {
13077       {
13078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13079       };
13080     }
13081   }
13082
13083   jresult = result;
13084   return jresult;
13085 }
13086
13087
13088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13089   unsigned int jresult ;
13090   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13091   Dali::Matrix *arg2 = 0 ;
13092   bool result;
13093
13094   arg1 = (Dali::Matrix *)jarg1;
13095   arg2 = (Dali::Matrix *)jarg2;
13096   if (!arg2) {
13097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13098     return 0;
13099   }
13100   {
13101     try {
13102       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13103     } catch (std::out_of_range& e) {
13104       {
13105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13106       };
13107     } catch (std::exception& e) {
13108       {
13109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13110       };
13111     } catch (Dali::DaliException e) {
13112       {
13113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13114       };
13115     } catch (...) {
13116       {
13117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13118       };
13119     }
13120   }
13121
13122   jresult = result;
13123   return jresult;
13124 }
13125
13126
13127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13128   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13129   Dali::Vector3 *arg2 = 0 ;
13130   Dali::Quaternion *arg3 = 0 ;
13131   Dali::Vector3 *arg4 = 0 ;
13132
13133   arg1 = (Dali::Matrix *)jarg1;
13134   arg2 = (Dali::Vector3 *)jarg2;
13135   if (!arg2) {
13136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13137     return ;
13138   }
13139   arg3 = (Dali::Quaternion *)jarg3;
13140   if (!arg3) {
13141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13142     return ;
13143   }
13144   arg4 = (Dali::Vector3 *)jarg4;
13145   if (!arg4) {
13146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13147     return ;
13148   }
13149   {
13150     try {
13151       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13152     } catch (std::out_of_range& e) {
13153       {
13154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13155       };
13156     } catch (std::exception& e) {
13157       {
13158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13159       };
13160     } catch (Dali::DaliException e) {
13161       {
13162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13163       };
13164     } catch (...) {
13165       {
13166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13167       };
13168     }
13169   }
13170
13171 }
13172
13173
13174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13175   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13176   Dali::Vector3 *arg2 = 0 ;
13177   Dali::Quaternion *arg3 = 0 ;
13178   Dali::Vector3 *arg4 = 0 ;
13179
13180   arg1 = (Dali::Matrix *)jarg1;
13181   arg2 = (Dali::Vector3 *)jarg2;
13182   if (!arg2) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13184     return ;
13185   }
13186   arg3 = (Dali::Quaternion *)jarg3;
13187   if (!arg3) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13189     return ;
13190   }
13191   arg4 = (Dali::Vector3 *)jarg4;
13192   if (!arg4) {
13193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13194     return ;
13195   }
13196   {
13197     try {
13198       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13199     } catch (std::out_of_range& e) {
13200       {
13201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13202       };
13203     } catch (std::exception& e) {
13204       {
13205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13206       };
13207     } catch (Dali::DaliException e) {
13208       {
13209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13210       };
13211     } catch (...) {
13212       {
13213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13214       };
13215     }
13216   }
13217
13218 }
13219
13220
13221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13222   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13223   Dali::Vector3 *arg2 = 0 ;
13224   Dali::Vector3 *arg3 = 0 ;
13225   Dali::Vector3 *arg4 = 0 ;
13226   Dali::Vector3 *arg5 = 0 ;
13227
13228   arg1 = (Dali::Matrix *)jarg1;
13229   arg2 = (Dali::Vector3 *)jarg2;
13230   if (!arg2) {
13231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13232     return ;
13233   }
13234   arg3 = (Dali::Vector3 *)jarg3;
13235   if (!arg3) {
13236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13237     return ;
13238   }
13239   arg4 = (Dali::Vector3 *)jarg4;
13240   if (!arg4) {
13241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13242     return ;
13243   }
13244   arg5 = (Dali::Vector3 *)jarg5;
13245   if (!arg5) {
13246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13247     return ;
13248   }
13249   {
13250     try {
13251       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13252     } catch (std::out_of_range& e) {
13253       {
13254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13255       };
13256     } catch (std::exception& e) {
13257       {
13258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13259       };
13260     } catch (Dali::DaliException e) {
13261       {
13262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13263       };
13264     } catch (...) {
13265       {
13266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13267       };
13268     }
13269   }
13270
13271 }
13272
13273
13274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13275   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13276   Dali::Vector3 *arg2 = 0 ;
13277   Dali::Quaternion *arg3 = 0 ;
13278   Dali::Vector3 *arg4 = 0 ;
13279
13280   arg1 = (Dali::Matrix *)jarg1;
13281   arg2 = (Dali::Vector3 *)jarg2;
13282   if (!arg2) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13284     return ;
13285   }
13286   arg3 = (Dali::Quaternion *)jarg3;
13287   if (!arg3) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13289     return ;
13290   }
13291   arg4 = (Dali::Vector3 *)jarg4;
13292   if (!arg4) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13294     return ;
13295   }
13296   {
13297     try {
13298       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13299     } catch (std::out_of_range& e) {
13300       {
13301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13302       };
13303     } catch (std::exception& e) {
13304       {
13305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13306       };
13307     } catch (Dali::DaliException e) {
13308       {
13309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13310       };
13311     } catch (...) {
13312       {
13313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13314       };
13315     }
13316   }
13317
13318 }
13319
13320
13321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13322   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13323
13324   arg1 = (Dali::Matrix *)jarg1;
13325   {
13326     try {
13327       delete arg1;
13328     } catch (std::out_of_range& e) {
13329       {
13330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13331       };
13332     } catch (std::exception& e) {
13333       {
13334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13335       };
13336     } catch (Dali::DaliException e) {
13337       {
13338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13339       };
13340     } catch (...) {
13341       {
13342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13343       };
13344     }
13345   }
13346
13347 }
13348
13349
13350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13351   void * jresult ;
13352   Dali::Matrix3 *result = 0 ;
13353
13354   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13355   jresult = (void *)result;
13356   return jresult;
13357 }
13358
13359
13360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13361   void * jresult ;
13362   Dali::Matrix3 *result = 0 ;
13363
13364   {
13365     try {
13366       result = (Dali::Matrix3 *)new Dali::Matrix3();
13367     } catch (std::out_of_range& e) {
13368       {
13369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13370       };
13371     } catch (std::exception& e) {
13372       {
13373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13374       };
13375     } catch (Dali::DaliException e) {
13376       {
13377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13378       };
13379     } catch (...) {
13380       {
13381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13382       };
13383     }
13384   }
13385
13386   jresult = (void *)result;
13387   return jresult;
13388 }
13389
13390
13391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13392   void * jresult ;
13393   Dali::Matrix3 *arg1 = 0 ;
13394   Dali::Matrix3 *result = 0 ;
13395
13396   arg1 = (Dali::Matrix3 *)jarg1;
13397   if (!arg1) {
13398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13399     return 0;
13400   }
13401   {
13402     try {
13403       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13404     } catch (std::out_of_range& e) {
13405       {
13406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13407       };
13408     } catch (std::exception& e) {
13409       {
13410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13411       };
13412     } catch (Dali::DaliException e) {
13413       {
13414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13415       };
13416     } catch (...) {
13417       {
13418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13419       };
13420     }
13421   }
13422
13423   jresult = (void *)result;
13424   return jresult;
13425 }
13426
13427
13428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13429   void * jresult ;
13430   Dali::Matrix *arg1 = 0 ;
13431   Dali::Matrix3 *result = 0 ;
13432
13433   arg1 = (Dali::Matrix *)jarg1;
13434   if (!arg1) {
13435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13436     return 0;
13437   }
13438   {
13439     try {
13440       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13441     } catch (std::out_of_range& e) {
13442       {
13443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13444       };
13445     } catch (std::exception& e) {
13446       {
13447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13448       };
13449     } catch (Dali::DaliException e) {
13450       {
13451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13452       };
13453     } catch (...) {
13454       {
13455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13456       };
13457     }
13458   }
13459
13460   jresult = (void *)result;
13461   return jresult;
13462 }
13463
13464
13465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13466   void * jresult ;
13467   float arg1 ;
13468   float arg2 ;
13469   float arg3 ;
13470   float arg4 ;
13471   float arg5 ;
13472   float arg6 ;
13473   float arg7 ;
13474   float arg8 ;
13475   float arg9 ;
13476   Dali::Matrix3 *result = 0 ;
13477
13478   arg1 = (float)jarg1;
13479   arg2 = (float)jarg2;
13480   arg3 = (float)jarg3;
13481   arg4 = (float)jarg4;
13482   arg5 = (float)jarg5;
13483   arg6 = (float)jarg6;
13484   arg7 = (float)jarg7;
13485   arg8 = (float)jarg8;
13486   arg9 = (float)jarg9;
13487   {
13488     try {
13489       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13490     } catch (std::out_of_range& e) {
13491       {
13492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13493       };
13494     } catch (std::exception& e) {
13495       {
13496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13497       };
13498     } catch (Dali::DaliException e) {
13499       {
13500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13501       };
13502     } catch (...) {
13503       {
13504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13505       };
13506     }
13507   }
13508
13509   jresult = (void *)result;
13510   return jresult;
13511 }
13512
13513
13514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13515   void * jresult ;
13516   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13517   Dali::Matrix3 *arg2 = 0 ;
13518   Dali::Matrix3 *result = 0 ;
13519
13520   arg1 = (Dali::Matrix3 *)jarg1;
13521   arg2 = (Dali::Matrix3 *)jarg2;
13522   if (!arg2) {
13523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13524     return 0;
13525   }
13526   {
13527     try {
13528       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13529     } catch (std::out_of_range& e) {
13530       {
13531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13532       };
13533     } catch (std::exception& e) {
13534       {
13535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13536       };
13537     } catch (Dali::DaliException e) {
13538       {
13539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13540       };
13541     } catch (...) {
13542       {
13543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13544       };
13545     }
13546   }
13547
13548   jresult = (void *)result;
13549   return jresult;
13550 }
13551
13552
13553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13554   void * jresult ;
13555   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13556   Dali::Matrix *arg2 = 0 ;
13557   Dali::Matrix3 *result = 0 ;
13558
13559   arg1 = (Dali::Matrix3 *)jarg1;
13560   arg2 = (Dali::Matrix *)jarg2;
13561   if (!arg2) {
13562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13563     return 0;
13564   }
13565   {
13566     try {
13567       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13568     } catch (std::out_of_range& e) {
13569       {
13570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13571       };
13572     } catch (std::exception& e) {
13573       {
13574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13575       };
13576     } catch (Dali::DaliException e) {
13577       {
13578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13579       };
13580     } catch (...) {
13581       {
13582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13583       };
13584     }
13585   }
13586
13587   jresult = (void *)result;
13588   return jresult;
13589 }
13590
13591
13592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13593   unsigned int jresult ;
13594   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13595   Dali::Matrix3 *arg2 = 0 ;
13596   bool result;
13597
13598   arg1 = (Dali::Matrix3 *)jarg1;
13599   arg2 = (Dali::Matrix3 *)jarg2;
13600   if (!arg2) {
13601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13602     return 0;
13603   }
13604   {
13605     try {
13606       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13607     } catch (std::out_of_range& e) {
13608       {
13609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13610       };
13611     } catch (std::exception& e) {
13612       {
13613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13614       };
13615     } catch (Dali::DaliException e) {
13616       {
13617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13618       };
13619     } catch (...) {
13620       {
13621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13622       };
13623     }
13624   }
13625
13626   jresult = result;
13627   return jresult;
13628 }
13629
13630
13631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13632   unsigned int jresult ;
13633   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13634   Dali::Matrix3 *arg2 = 0 ;
13635   bool result;
13636
13637   arg1 = (Dali::Matrix3 *)jarg1;
13638   arg2 = (Dali::Matrix3 *)jarg2;
13639   if (!arg2) {
13640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13641     return 0;
13642   }
13643   {
13644     try {
13645       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13646     } catch (std::out_of_range& e) {
13647       {
13648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13649       };
13650     } catch (std::exception& e) {
13651       {
13652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13653       };
13654     } catch (Dali::DaliException e) {
13655       {
13656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13657       };
13658     } catch (...) {
13659       {
13660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13661       };
13662     }
13663   }
13664
13665   jresult = result;
13666   return jresult;
13667 }
13668
13669
13670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13671   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13672
13673   arg1 = (Dali::Matrix3 *)jarg1;
13674   {
13675     try {
13676       delete arg1;
13677     } catch (std::out_of_range& e) {
13678       {
13679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13680       };
13681     } catch (std::exception& e) {
13682       {
13683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13684       };
13685     } catch (Dali::DaliException e) {
13686       {
13687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13688       };
13689     } catch (...) {
13690       {
13691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13692       };
13693     }
13694   }
13695
13696 }
13697
13698
13699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13700   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13701
13702   arg1 = (Dali::Matrix3 *)jarg1;
13703   {
13704     try {
13705       (arg1)->SetIdentity();
13706     } catch (std::out_of_range& e) {
13707       {
13708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13709       };
13710     } catch (std::exception& e) {
13711       {
13712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13713       };
13714     } catch (Dali::DaliException e) {
13715       {
13716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13717       };
13718     } catch (...) {
13719       {
13720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13721       };
13722     }
13723   }
13724
13725 }
13726
13727
13728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13729   void * jresult ;
13730   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13731   float *result = 0 ;
13732
13733   arg1 = (Dali::Matrix3 *)jarg1;
13734   {
13735     try {
13736       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13737     } catch (std::out_of_range& e) {
13738       {
13739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13740       };
13741     } catch (std::exception& e) {
13742       {
13743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13744       };
13745     } catch (Dali::DaliException e) {
13746       {
13747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13748       };
13749     } catch (...) {
13750       {
13751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13752       };
13753     }
13754   }
13755
13756   jresult = (void *)result;
13757   return jresult;
13758 }
13759
13760
13761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13762   unsigned int jresult ;
13763   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13764   bool result;
13765
13766   arg1 = (Dali::Matrix3 *)jarg1;
13767   {
13768     try {
13769       result = (bool)(arg1)->Invert();
13770     } catch (std::out_of_range& e) {
13771       {
13772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13773       };
13774     } catch (std::exception& e) {
13775       {
13776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13777       };
13778     } catch (Dali::DaliException e) {
13779       {
13780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13781       };
13782     } catch (...) {
13783       {
13784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13785       };
13786     }
13787   }
13788
13789   jresult = result;
13790   return jresult;
13791 }
13792
13793
13794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13795   unsigned int jresult ;
13796   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13797   bool result;
13798
13799   arg1 = (Dali::Matrix3 *)jarg1;
13800   {
13801     try {
13802       result = (bool)(arg1)->Transpose();
13803     } catch (std::out_of_range& e) {
13804       {
13805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13806       };
13807     } catch (std::exception& e) {
13808       {
13809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13810       };
13811     } catch (Dali::DaliException e) {
13812       {
13813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13814       };
13815     } catch (...) {
13816       {
13817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13818       };
13819     }
13820   }
13821
13822   jresult = result;
13823   return jresult;
13824 }
13825
13826
13827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13828   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13829   float arg2 ;
13830
13831   arg1 = (Dali::Matrix3 *)jarg1;
13832   arg2 = (float)jarg2;
13833   {
13834     try {
13835       (arg1)->Scale(arg2);
13836     } catch (std::out_of_range& e) {
13837       {
13838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13839       };
13840     } catch (std::exception& e) {
13841       {
13842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13843       };
13844     } catch (Dali::DaliException e) {
13845       {
13846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13847       };
13848     } catch (...) {
13849       {
13850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13851       };
13852     }
13853   }
13854
13855 }
13856
13857
13858 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13859   float jresult ;
13860   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13861   float result;
13862
13863   arg1 = (Dali::Matrix3 *)jarg1;
13864   {
13865     try {
13866       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13867     } catch (std::out_of_range& e) {
13868       {
13869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13870       };
13871     } catch (std::exception& e) {
13872       {
13873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13874       };
13875     } catch (Dali::DaliException e) {
13876       {
13877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13878       };
13879     } catch (...) {
13880       {
13881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13882       };
13883     }
13884   }
13885
13886   jresult = result;
13887   return jresult;
13888 }
13889
13890
13891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13892   unsigned int jresult ;
13893   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13894   bool result;
13895
13896   arg1 = (Dali::Matrix3 *)jarg1;
13897   {
13898     try {
13899       result = (bool)(arg1)->ScaledInverseTranspose();
13900     } catch (std::out_of_range& e) {
13901       {
13902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13903       };
13904     } catch (std::exception& e) {
13905       {
13906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13907       };
13908     } catch (Dali::DaliException e) {
13909       {
13910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13911       };
13912     } catch (...) {
13913       {
13914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13915       };
13916     }
13917   }
13918
13919   jresult = result;
13920   return jresult;
13921 }
13922
13923
13924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13925   Dali::Matrix3 *arg1 = 0 ;
13926   Dali::Matrix3 *arg2 = 0 ;
13927   Dali::Matrix3 *arg3 = 0 ;
13928
13929   arg1 = (Dali::Matrix3 *)jarg1;
13930   if (!arg1) {
13931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13932     return ;
13933   }
13934   arg2 = (Dali::Matrix3 *)jarg2;
13935   if (!arg2) {
13936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13937     return ;
13938   }
13939   arg3 = (Dali::Matrix3 *)jarg3;
13940   if (!arg3) {
13941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13942     return ;
13943   }
13944   {
13945     try {
13946       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13947     } catch (std::out_of_range& e) {
13948       {
13949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13950       };
13951     } catch (std::exception& e) {
13952       {
13953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13954       };
13955     } catch (Dali::DaliException e) {
13956       {
13957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13958       };
13959     } catch (...) {
13960       {
13961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13962       };
13963     }
13964   }
13965
13966 }
13967
13968
13969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13970   float jresult ;
13971   float arg1 ;
13972   float arg2 ;
13973   float result;
13974
13975   arg1 = (float)jarg1;
13976   arg2 = (float)jarg2;
13977   {
13978     try {
13979       result = (float)Dali::Random::Range(arg1,arg2);
13980     } catch (std::out_of_range& e) {
13981       {
13982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13983       };
13984     } catch (std::exception& e) {
13985       {
13986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13987       };
13988     } catch (Dali::DaliException e) {
13989       {
13990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13991       };
13992     } catch (...) {
13993       {
13994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13995       };
13996     }
13997   }
13998
13999   jresult = result;
14000   return jresult;
14001 }
14002
14003
14004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14005   void * jresult ;
14006   Dali::Vector4 result;
14007
14008   {
14009     try {
14010       result = Dali::Random::Axis();
14011     } catch (std::out_of_range& e) {
14012       {
14013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14014       };
14015     } catch (std::exception& e) {
14016       {
14017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14018       };
14019     } catch (Dali::DaliException e) {
14020       {
14021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14022       };
14023     } catch (...) {
14024       {
14025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14026       };
14027     }
14028   }
14029
14030   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14031   return jresult;
14032 }
14033
14034
14035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14036   void * jresult ;
14037   Dali::AngleAxis *result = 0 ;
14038
14039   {
14040     try {
14041       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14042     } catch (std::out_of_range& e) {
14043       {
14044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14045       };
14046     } catch (std::exception& e) {
14047       {
14048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14049       };
14050     } catch (Dali::DaliException e) {
14051       {
14052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14053       };
14054     } catch (...) {
14055       {
14056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14057       };
14058     }
14059   }
14060
14061   jresult = (void *)result;
14062   return jresult;
14063 }
14064
14065
14066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14067   void * jresult ;
14068   Dali::Radian arg1 ;
14069   Dali::Vector3 *arg2 = 0 ;
14070   Dali::Radian *argp1 ;
14071   Dali::AngleAxis *result = 0 ;
14072
14073   argp1 = (Dali::Radian *)jarg1;
14074   if (!argp1) {
14075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14076     return 0;
14077   }
14078   arg1 = *argp1;
14079   arg2 = (Dali::Vector3 *)jarg2;
14080   if (!arg2) {
14081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14082     return 0;
14083   }
14084   {
14085     try {
14086       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14087     } catch (std::out_of_range& e) {
14088       {
14089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14090       };
14091     } catch (std::exception& e) {
14092       {
14093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14094       };
14095     } catch (Dali::DaliException e) {
14096       {
14097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14098       };
14099     } catch (...) {
14100       {
14101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14102       };
14103     }
14104   }
14105
14106   jresult = (void *)result;
14107   return jresult;
14108 }
14109
14110
14111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14112   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14113   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14114
14115   arg1 = (Dali::AngleAxis *)jarg1;
14116   arg2 = (Dali::Radian *)jarg2;
14117   if (arg1) (arg1)->angle = *arg2;
14118 }
14119
14120
14121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14122   void * jresult ;
14123   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14124   Dali::Radian *result = 0 ;
14125
14126   arg1 = (Dali::AngleAxis *)jarg1;
14127   result = (Dali::Radian *)& ((arg1)->angle);
14128   jresult = (void *)result;
14129   return jresult;
14130 }
14131
14132
14133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14134   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14135   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14136
14137   arg1 = (Dali::AngleAxis *)jarg1;
14138   arg2 = (Dali::Vector3 *)jarg2;
14139   if (arg1) (arg1)->axis = *arg2;
14140 }
14141
14142
14143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14144   void * jresult ;
14145   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14146   Dali::Vector3 *result = 0 ;
14147
14148   arg1 = (Dali::AngleAxis *)jarg1;
14149   result = (Dali::Vector3 *)& ((arg1)->axis);
14150   jresult = (void *)result;
14151   return jresult;
14152 }
14153
14154
14155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14156   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14157
14158   arg1 = (Dali::AngleAxis *)jarg1;
14159   {
14160     try {
14161       delete arg1;
14162     } catch (std::out_of_range& e) {
14163       {
14164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14165       };
14166     } catch (std::exception& e) {
14167       {
14168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14169       };
14170     } catch (Dali::DaliException e) {
14171       {
14172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14173       };
14174     } catch (...) {
14175       {
14176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14177       };
14178     }
14179   }
14180
14181 }
14182
14183
14184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14185   unsigned int jresult ;
14186   Dali::AngleAxis *arg1 = 0 ;
14187   Dali::AngleAxis *arg2 = 0 ;
14188   bool result;
14189
14190   arg1 = (Dali::AngleAxis *)jarg1;
14191   if (!arg1) {
14192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14193     return 0;
14194   }
14195   arg2 = (Dali::AngleAxis *)jarg2;
14196   if (!arg2) {
14197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14198     return 0;
14199   }
14200   {
14201     try {
14202       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14203     } catch (std::out_of_range& e) {
14204       {
14205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14206       };
14207     } catch (std::exception& e) {
14208       {
14209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14210       };
14211     } catch (Dali::DaliException e) {
14212       {
14213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14214       };
14215     } catch (...) {
14216       {
14217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14218       };
14219     }
14220   }
14221
14222   jresult = result;
14223   return jresult;
14224 }
14225
14226
14227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14228   unsigned int jresult ;
14229   unsigned int arg1 ;
14230   unsigned int result;
14231
14232   arg1 = (unsigned int)jarg1;
14233   {
14234     try {
14235       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14236     } catch (std::out_of_range& e) {
14237       {
14238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14239       };
14240     } catch (std::exception& e) {
14241       {
14242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14243       };
14244     } catch (Dali::DaliException e) {
14245       {
14246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14247       };
14248     } catch (...) {
14249       {
14250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14251       };
14252     }
14253   }
14254
14255   jresult = result;
14256   return jresult;
14257 }
14258
14259
14260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14261   unsigned int jresult ;
14262   unsigned int arg1 ;
14263   bool result;
14264
14265   arg1 = (unsigned int)jarg1;
14266   {
14267     try {
14268       result = (bool)Dali::IsPowerOfTwo(arg1);
14269     } catch (std::out_of_range& e) {
14270       {
14271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14272       };
14273     } catch (std::exception& e) {
14274       {
14275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14276       };
14277     } catch (Dali::DaliException e) {
14278       {
14279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14280       };
14281     } catch (...) {
14282       {
14283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14284       };
14285     }
14286   }
14287
14288   jresult = result;
14289   return jresult;
14290 }
14291
14292
14293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14294   float jresult ;
14295   float arg1 ;
14296   float arg2 ;
14297   float result;
14298
14299   arg1 = (float)jarg1;
14300   arg2 = (float)jarg2;
14301   {
14302     try {
14303       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14304     } catch (std::out_of_range& e) {
14305       {
14306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14307       };
14308     } catch (std::exception& e) {
14309       {
14310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14311       };
14312     } catch (Dali::DaliException e) {
14313       {
14314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14315       };
14316     } catch (...) {
14317       {
14318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14319       };
14320     }
14321   }
14322
14323   jresult = result;
14324   return jresult;
14325 }
14326
14327
14328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14329   unsigned int jresult ;
14330   float arg1 ;
14331   bool result;
14332
14333   arg1 = (float)jarg1;
14334   {
14335     try {
14336       result = (bool)Dali::EqualsZero(arg1);
14337     } catch (std::out_of_range& e) {
14338       {
14339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14340       };
14341     } catch (std::exception& e) {
14342       {
14343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14344       };
14345     } catch (Dali::DaliException e) {
14346       {
14347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14348       };
14349     } catch (...) {
14350       {
14351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14352       };
14353     }
14354   }
14355
14356   jresult = result;
14357   return jresult;
14358 }
14359
14360
14361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14362   unsigned int jresult ;
14363   float arg1 ;
14364   float arg2 ;
14365   bool result;
14366
14367   arg1 = (float)jarg1;
14368   arg2 = (float)jarg2;
14369   {
14370     try {
14371       result = (bool)Dali::Equals(arg1,arg2);
14372     } catch (std::out_of_range& e) {
14373       {
14374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14375       };
14376     } catch (std::exception& e) {
14377       {
14378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14379       };
14380     } catch (Dali::DaliException e) {
14381       {
14382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14383       };
14384     } catch (...) {
14385       {
14386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14387       };
14388     }
14389   }
14390
14391   jresult = result;
14392   return jresult;
14393 }
14394
14395
14396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14397   unsigned int jresult ;
14398   float arg1 ;
14399   float arg2 ;
14400   float arg3 ;
14401   bool result;
14402
14403   arg1 = (float)jarg1;
14404   arg2 = (float)jarg2;
14405   arg3 = (float)jarg3;
14406   {
14407     try {
14408       result = (bool)Dali::Equals(arg1,arg2,arg3);
14409     } catch (std::out_of_range& e) {
14410       {
14411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14412       };
14413     } catch (std::exception& e) {
14414       {
14415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14416       };
14417     } catch (Dali::DaliException e) {
14418       {
14419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14420       };
14421     } catch (...) {
14422       {
14423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14424       };
14425     }
14426   }
14427
14428   jresult = result;
14429   return jresult;
14430 }
14431
14432
14433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14434   float jresult ;
14435   float arg1 ;
14436   int arg2 ;
14437   float result;
14438
14439   arg1 = (float)jarg1;
14440   arg2 = (int)jarg2;
14441   {
14442     try {
14443       result = (float)Dali::Round(arg1,arg2);
14444     } catch (std::out_of_range& e) {
14445       {
14446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14447       };
14448     } catch (std::exception& e) {
14449       {
14450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14451       };
14452     } catch (Dali::DaliException e) {
14453       {
14454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14455       };
14456     } catch (...) {
14457       {
14458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14459       };
14460     }
14461   }
14462
14463   jresult = result;
14464   return jresult;
14465 }
14466
14467
14468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14469   float jresult ;
14470   float arg1 ;
14471   float arg2 ;
14472   float arg3 ;
14473   float result;
14474
14475   arg1 = (float)jarg1;
14476   arg2 = (float)jarg2;
14477   arg3 = (float)jarg3;
14478   {
14479     try {
14480       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14481     } catch (std::out_of_range& e) {
14482       {
14483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14484       };
14485     } catch (std::exception& e) {
14486       {
14487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14488       };
14489     } catch (Dali::DaliException e) {
14490       {
14491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14492       };
14493     } catch (...) {
14494       {
14495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14496       };
14497     }
14498   }
14499
14500   jresult = result;
14501   return jresult;
14502 }
14503
14504
14505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14506   float jresult ;
14507   float arg1 ;
14508   float arg2 ;
14509   float arg3 ;
14510   float arg4 ;
14511   float result;
14512
14513   arg1 = (float)jarg1;
14514   arg2 = (float)jarg2;
14515   arg3 = (float)jarg3;
14516   arg4 = (float)jarg4;
14517   {
14518     try {
14519       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14520     } catch (std::out_of_range& e) {
14521       {
14522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14523       };
14524     } catch (std::exception& e) {
14525       {
14526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14527       };
14528     } catch (Dali::DaliException e) {
14529       {
14530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14531       };
14532     } catch (...) {
14533       {
14534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14535       };
14536     }
14537   }
14538
14539   jresult = result;
14540   return jresult;
14541 }
14542
14543
14544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14545   int jresult ;
14546   int result;
14547
14548   result = (int)(int)Dali::Property::INVALID_INDEX;
14549   jresult = result;
14550   return jresult;
14551 }
14552
14553
14554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14555   int jresult ;
14556   int result;
14557
14558   result = (int)(int)Dali::Property::INVALID_KEY;
14559   jresult = result;
14560   return jresult;
14561 }
14562
14563
14564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14565   int jresult ;
14566   int result;
14567
14568   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14569   jresult = result;
14570   return jresult;
14571 }
14572
14573
14574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14575   void * jresult ;
14576   Dali::Handle *arg1 = 0 ;
14577   Dali::Property::Index arg2 ;
14578   Dali::Property *result = 0 ;
14579
14580   arg1 = (Dali::Handle *)jarg1;
14581   if (!arg1) {
14582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14583     return 0;
14584   }
14585   arg2 = (Dali::Property::Index)jarg2;
14586   {
14587     try {
14588       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14589     } catch (std::out_of_range& e) {
14590       {
14591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14592       };
14593     } catch (std::exception& e) {
14594       {
14595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14596       };
14597     } catch (Dali::DaliException e) {
14598       {
14599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14600       };
14601     } catch (...) {
14602       {
14603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14604       };
14605     }
14606   }
14607
14608   jresult = (void *)result;
14609   return jresult;
14610 }
14611
14612
14613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14614   void * jresult ;
14615   Dali::Handle *arg1 = 0 ;
14616   Dali::Property::Index arg2 ;
14617   int arg3 ;
14618   Dali::Property *result = 0 ;
14619
14620   arg1 = (Dali::Handle *)jarg1;
14621   if (!arg1) {
14622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14623     return 0;
14624   }
14625   arg2 = (Dali::Property::Index)jarg2;
14626   arg3 = (int)jarg3;
14627   {
14628     try {
14629       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14630     } catch (std::out_of_range& e) {
14631       {
14632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14633       };
14634     } catch (std::exception& e) {
14635       {
14636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14637       };
14638     } catch (Dali::DaliException e) {
14639       {
14640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14641       };
14642     } catch (...) {
14643       {
14644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14645       };
14646     }
14647   }
14648
14649   jresult = (void *)result;
14650   return jresult;
14651 }
14652
14653
14654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14655   void * jresult ;
14656   Dali::Handle *arg1 = 0 ;
14657   std::string *arg2 = 0 ;
14658   Dali::Property *result = 0 ;
14659
14660   arg1 = (Dali::Handle *)jarg1;
14661   if (!arg1) {
14662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14663     return 0;
14664   }
14665   if (!jarg2) {
14666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14667     return 0;
14668   }
14669   std::string arg2_str(jarg2);
14670   arg2 = &arg2_str;
14671   {
14672     try {
14673       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14674     } catch (std::out_of_range& e) {
14675       {
14676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14677       };
14678     } catch (std::exception& e) {
14679       {
14680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14681       };
14682     } catch (Dali::DaliException e) {
14683       {
14684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14685       };
14686     } catch (...) {
14687       {
14688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14689       };
14690     }
14691   }
14692
14693   jresult = (void *)result;
14694
14695   //argout typemap for const std::string&
14696
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14702   void * jresult ;
14703   Dali::Handle *arg1 = 0 ;
14704   std::string *arg2 = 0 ;
14705   int arg3 ;
14706   Dali::Property *result = 0 ;
14707
14708   arg1 = (Dali::Handle *)jarg1;
14709   if (!arg1) {
14710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14711     return 0;
14712   }
14713   if (!jarg2) {
14714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14715     return 0;
14716   }
14717   std::string arg2_str(jarg2);
14718   arg2 = &arg2_str;
14719   arg3 = (int)jarg3;
14720   {
14721     try {
14722       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14723     } catch (std::out_of_range& e) {
14724       {
14725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14726       };
14727     } catch (std::exception& e) {
14728       {
14729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14730       };
14731     } catch (Dali::DaliException e) {
14732       {
14733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14734       };
14735     } catch (...) {
14736       {
14737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14738       };
14739     }
14740   }
14741
14742   jresult = (void *)result;
14743
14744   //argout typemap for const std::string&
14745
14746   return jresult;
14747 }
14748
14749
14750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14751   Dali::Property *arg1 = (Dali::Property *) 0 ;
14752
14753   arg1 = (Dali::Property *)jarg1;
14754   {
14755     try {
14756       delete arg1;
14757     } catch (std::out_of_range& e) {
14758       {
14759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14760       };
14761     } catch (std::exception& e) {
14762       {
14763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14764       };
14765     } catch (Dali::DaliException e) {
14766       {
14767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14768       };
14769     } catch (...) {
14770       {
14771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14772       };
14773     }
14774   }
14775
14776 }
14777
14778
14779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14780   Dali::Property *arg1 = (Dali::Property *) 0 ;
14781   Dali::Handle *arg2 = 0 ;
14782
14783   arg1 = (Dali::Property *)jarg1;
14784   arg2 = (Dali::Handle *)jarg2;
14785   if (!arg2) {
14786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14787     return ;
14788   }
14789   if (arg1) (arg1)->object = *arg2;
14790 }
14791
14792
14793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14794   void * jresult ;
14795   Dali::Property *arg1 = (Dali::Property *) 0 ;
14796   Dali::Handle *result = 0 ;
14797
14798   arg1 = (Dali::Property *)jarg1;
14799   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14800   jresult = (void *)result;
14801   return jresult;
14802 }
14803
14804
14805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14806   Dali::Property *arg1 = (Dali::Property *) 0 ;
14807   Dali::Property::Index arg2 ;
14808
14809   arg1 = (Dali::Property *)jarg1;
14810   arg2 = (Dali::Property::Index)jarg2;
14811   if (arg1) (arg1)->propertyIndex = arg2;
14812 }
14813
14814
14815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14816   int jresult ;
14817   Dali::Property *arg1 = (Dali::Property *) 0 ;
14818   Dali::Property::Index result;
14819
14820   arg1 = (Dali::Property *)jarg1;
14821   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14822   jresult = result;
14823   return jresult;
14824 }
14825
14826
14827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14828   Dali::Property *arg1 = (Dali::Property *) 0 ;
14829   int arg2 ;
14830
14831   arg1 = (Dali::Property *)jarg1;
14832   arg2 = (int)jarg2;
14833   if (arg1) (arg1)->componentIndex = arg2;
14834 }
14835
14836
14837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14838   int jresult ;
14839   Dali::Property *arg1 = (Dali::Property *) 0 ;
14840   int result;
14841
14842   arg1 = (Dali::Property *)jarg1;
14843   result = (int) ((arg1)->componentIndex);
14844   jresult = result;
14845   return jresult;
14846 }
14847
14848
14849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14850   void * jresult ;
14851   Dali::Property::Array *result = 0 ;
14852
14853   {
14854     try {
14855       result = (Dali::Property::Array *)new Dali::Property::Array();
14856     } catch (std::out_of_range& e) {
14857       {
14858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14859       };
14860     } catch (std::exception& e) {
14861       {
14862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14863       };
14864     } catch (Dali::DaliException e) {
14865       {
14866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14867       };
14868     } catch (...) {
14869       {
14870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14871       };
14872     }
14873   }
14874
14875   jresult = (void *)result;
14876   return jresult;
14877 }
14878
14879
14880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14881   void * jresult ;
14882   Dali::Property::Array *arg1 = 0 ;
14883   Dali::Property::Array *result = 0 ;
14884
14885   arg1 = (Dali::Property::Array *)jarg1;
14886   if (!arg1) {
14887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14888     return 0;
14889   }
14890   {
14891     try {
14892       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14893     } catch (std::out_of_range& e) {
14894       {
14895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14896       };
14897     } catch (std::exception& e) {
14898       {
14899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14900       };
14901     } catch (Dali::DaliException e) {
14902       {
14903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14904       };
14905     } catch (...) {
14906       {
14907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14908       };
14909     }
14910   }
14911
14912   jresult = (void *)result;
14913   return jresult;
14914 }
14915
14916
14917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14918   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14919
14920   arg1 = (Dali::Property::Array *)jarg1;
14921   {
14922     try {
14923       delete arg1;
14924     } catch (std::out_of_range& e) {
14925       {
14926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14927       };
14928     } catch (std::exception& e) {
14929       {
14930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14931       };
14932     } catch (Dali::DaliException e) {
14933       {
14934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14935       };
14936     } catch (...) {
14937       {
14938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14939       };
14940     }
14941   }
14942
14943 }
14944
14945
14946 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14947   unsigned long jresult ;
14948   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14949   Dali::Property::Array::SizeType result;
14950
14951   arg1 = (Dali::Property::Array *)jarg1;
14952   {
14953     try {
14954       result = ((Dali::Property::Array const *)arg1)->Size();
14955     } catch (std::out_of_range& e) {
14956       {
14957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14958       };
14959     } catch (std::exception& e) {
14960       {
14961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14962       };
14963     } catch (Dali::DaliException e) {
14964       {
14965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14966       };
14967     } catch (...) {
14968       {
14969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14970       };
14971     }
14972   }
14973
14974   jresult = (unsigned long)result;
14975   return jresult;
14976 }
14977
14978
14979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14980   unsigned long jresult ;
14981   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14982   Dali::Property::Array::SizeType result;
14983
14984   arg1 = (Dali::Property::Array *)jarg1;
14985   {
14986     try {
14987       result = ((Dali::Property::Array const *)arg1)->Count();
14988     } catch (std::out_of_range& e) {
14989       {
14990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14991       };
14992     } catch (std::exception& e) {
14993       {
14994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14995       };
14996     } catch (Dali::DaliException e) {
14997       {
14998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14999       };
15000     } catch (...) {
15001       {
15002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15003       };
15004     }
15005   }
15006
15007   jresult = (unsigned long)result;
15008   return jresult;
15009 }
15010
15011
15012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15013   unsigned int jresult ;
15014   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15015   bool result;
15016
15017   arg1 = (Dali::Property::Array *)jarg1;
15018   {
15019     try {
15020       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15021     } catch (std::out_of_range& e) {
15022       {
15023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15024       };
15025     } catch (std::exception& e) {
15026       {
15027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15028       };
15029     } catch (Dali::DaliException e) {
15030       {
15031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15032       };
15033     } catch (...) {
15034       {
15035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15036       };
15037     }
15038   }
15039
15040   jresult = result;
15041   return jresult;
15042 }
15043
15044
15045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15046   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15047
15048   arg1 = (Dali::Property::Array *)jarg1;
15049   {
15050     try {
15051       (arg1)->Clear();
15052     } catch (std::out_of_range& e) {
15053       {
15054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15055       };
15056     } catch (std::exception& e) {
15057       {
15058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15059       };
15060     } catch (Dali::DaliException e) {
15061       {
15062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15063       };
15064     } catch (...) {
15065       {
15066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15067       };
15068     }
15069   }
15070
15071 }
15072
15073
15074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15075   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15076   Dali::Property::Array::SizeType arg2 ;
15077
15078   arg1 = (Dali::Property::Array *)jarg1;
15079   arg2 = (Dali::Property::Array::SizeType)jarg2;
15080   {
15081     try {
15082       (arg1)->Reserve(arg2);
15083     } catch (std::out_of_range& e) {
15084       {
15085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15086       };
15087     } catch (std::exception& e) {
15088       {
15089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15090       };
15091     } catch (Dali::DaliException e) {
15092       {
15093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15094       };
15095     } catch (...) {
15096       {
15097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15098       };
15099     }
15100   }
15101
15102 }
15103
15104
15105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15106   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15107   Dali::Property::Array::SizeType arg2 ;
15108
15109   arg1 = (Dali::Property::Array *)jarg1;
15110   arg2 = (Dali::Property::Array::SizeType)jarg2;
15111   {
15112     try {
15113       (arg1)->Resize(arg2);
15114     } catch (std::out_of_range& e) {
15115       {
15116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15117       };
15118     } catch (std::exception& e) {
15119       {
15120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15121       };
15122     } catch (Dali::DaliException e) {
15123       {
15124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15125       };
15126     } catch (...) {
15127       {
15128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15129       };
15130     }
15131   }
15132
15133 }
15134
15135
15136 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15137   unsigned long jresult ;
15138   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15139   Dali::Property::Array::SizeType result;
15140
15141   arg1 = (Dali::Property::Array *)jarg1;
15142   {
15143     try {
15144       result = (arg1)->Capacity();
15145     } catch (std::out_of_range& e) {
15146       {
15147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15148       };
15149     } catch (std::exception& e) {
15150       {
15151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15152       };
15153     } catch (Dali::DaliException e) {
15154       {
15155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15156       };
15157     } catch (...) {
15158       {
15159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15160       };
15161     }
15162   }
15163
15164   jresult = (unsigned long)result;
15165   return jresult;
15166 }
15167
15168
15169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15170   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15171   Dali::Property::Value *arg2 = 0 ;
15172
15173   arg1 = (Dali::Property::Array *)jarg1;
15174   arg2 = (Dali::Property::Value *)jarg2;
15175   if (!arg2) {
15176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15177     return ;
15178   }
15179   {
15180     try {
15181       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15182     } catch (std::out_of_range& e) {
15183       {
15184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15185       };
15186     } catch (std::exception& e) {
15187       {
15188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15189       };
15190     } catch (Dali::DaliException e) {
15191       {
15192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15193       };
15194     } catch (...) {
15195       {
15196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15197       };
15198     }
15199   }
15200
15201 }
15202
15203
15204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15205   void * jresult ;
15206   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15207   Dali::Property::Value *arg2 = 0 ;
15208   Dali::Property::Array *result = 0 ;
15209
15210   arg1 = (Dali::Property::Array *)jarg1;
15211   arg2 = (Dali::Property::Value *)jarg2;
15212   if (!arg2) {
15213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15214     return 0;
15215   }
15216   {
15217     try {
15218       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15219     } catch (std::out_of_range& e) {
15220       {
15221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15222       };
15223     } catch (std::exception& e) {
15224       {
15225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15226       };
15227     } catch (Dali::DaliException e) {
15228       {
15229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15230       };
15231     } catch (...) {
15232       {
15233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15234       };
15235     }
15236   }
15237
15238   jresult = (void *)result;
15239   return jresult;
15240 }
15241
15242
15243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15244   void * jresult ;
15245   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15246   Dali::Property::Array::SizeType arg2 ;
15247   Dali::Property::Value *result = 0 ;
15248
15249   arg1 = (Dali::Property::Array *)jarg1;
15250   arg2 = (Dali::Property::Array::SizeType)jarg2;
15251   {
15252     try {
15253       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15254     } catch (std::out_of_range& e) {
15255       {
15256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15257       };
15258     } catch (std::exception& e) {
15259       {
15260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15261       };
15262     } catch (Dali::DaliException e) {
15263       {
15264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15265       };
15266     } catch (...) {
15267       {
15268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15269       };
15270     }
15271   }
15272
15273   jresult = (void *)result;
15274   return jresult;
15275 }
15276
15277
15278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15279   void * jresult ;
15280   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15281   Dali::Property::Array::SizeType arg2 ;
15282   Dali::Property::Value *result = 0 ;
15283
15284   arg1 = (Dali::Property::Array *)jarg1;
15285   arg2 = (Dali::Property::Array::SizeType)jarg2;
15286   {
15287     try {
15288       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15289     } catch (std::out_of_range& e) {
15290       {
15291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15292       };
15293     } catch (std::exception& e) {
15294       {
15295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15296       };
15297     } catch (Dali::DaliException e) {
15298       {
15299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15300       };
15301     } catch (...) {
15302       {
15303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15304       };
15305     }
15306   }
15307
15308   jresult = (void *)result;
15309   return jresult;
15310 }
15311
15312
15313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15314   void * jresult ;
15315   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15316   Dali::Property::Array *arg2 = 0 ;
15317   Dali::Property::Array *result = 0 ;
15318
15319   arg1 = (Dali::Property::Array *)jarg1;
15320   arg2 = (Dali::Property::Array *)jarg2;
15321   if (!arg2) {
15322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15323     return 0;
15324   }
15325   {
15326     try {
15327       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15328     } catch (std::out_of_range& e) {
15329       {
15330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15331       };
15332     } catch (std::exception& e) {
15333       {
15334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15335       };
15336     } catch (Dali::DaliException e) {
15337       {
15338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15339       };
15340     } catch (...) {
15341       {
15342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15343       };
15344     }
15345   }
15346
15347   jresult = (void *)result;
15348   return jresult;
15349 }
15350
15351
15352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15353   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15354   enum Dali::Property::Key::Type arg2 ;
15355
15356   arg1 = (Dali::Property::Key *)jarg1;
15357   arg2 = (enum Dali::Property::Key::Type)jarg2;
15358   if (arg1) (arg1)->type = arg2;
15359 }
15360
15361
15362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15363   int jresult ;
15364   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15365   enum Dali::Property::Key::Type result;
15366
15367   arg1 = (Dali::Property::Key *)jarg1;
15368   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15369   jresult = (int)result;
15370   return jresult;
15371 }
15372
15373
15374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15375   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15376   Dali::Property::Index arg2 ;
15377
15378   arg1 = (Dali::Property::Key *)jarg1;
15379   arg2 = (Dali::Property::Index)jarg2;
15380   if (arg1) (arg1)->indexKey = arg2;
15381 }
15382
15383
15384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15385   int jresult ;
15386   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15387   Dali::Property::Index result;
15388
15389   arg1 = (Dali::Property::Key *)jarg1;
15390   result = (Dali::Property::Index) ((arg1)->indexKey);
15391   jresult = result;
15392   return jresult;
15393 }
15394
15395
15396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15397   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15398   std::string *arg2 = 0 ;
15399
15400   arg1 = (Dali::Property::Key *)jarg1;
15401   if (!jarg2) {
15402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15403     return ;
15404   }
15405   std::string arg2_str(jarg2);
15406   arg2 = &arg2_str;
15407   if (arg1) (arg1)->stringKey = *arg2;
15408
15409   //argout typemap for const std::string&
15410
15411 }
15412
15413
15414 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15415   char * jresult ;
15416   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15417   std::string *result = 0 ;
15418
15419   arg1 = (Dali::Property::Key *)jarg1;
15420   result = (std::string *) & ((arg1)->stringKey);
15421   jresult = SWIG_csharp_string_callback(result->c_str());
15422   return jresult;
15423 }
15424
15425
15426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15427   void * jresult ;
15428   std::string *arg1 = 0 ;
15429   Dali::Property::Key *result = 0 ;
15430
15431   if (!jarg1) {
15432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15433     return 0;
15434   }
15435   std::string arg1_str(jarg1);
15436   arg1 = &arg1_str;
15437   {
15438     try {
15439       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15440     } catch (std::out_of_range& e) {
15441       {
15442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15443       };
15444     } catch (std::exception& e) {
15445       {
15446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15447       };
15448     } catch (Dali::DaliException e) {
15449       {
15450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15451       };
15452     } catch (...) {
15453       {
15454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15455       };
15456     }
15457   }
15458
15459   jresult = (void *)result;
15460
15461   //argout typemap for const std::string&
15462
15463   return jresult;
15464 }
15465
15466
15467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15468   void * jresult ;
15469   Dali::Property::Index arg1 ;
15470   Dali::Property::Key *result = 0 ;
15471
15472   arg1 = (Dali::Property::Index)jarg1;
15473   {
15474     try {
15475       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15476     } catch (std::out_of_range& e) {
15477       {
15478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15479       };
15480     } catch (std::exception& e) {
15481       {
15482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15483       };
15484     } catch (Dali::DaliException e) {
15485       {
15486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15487       };
15488     } catch (...) {
15489       {
15490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15491       };
15492     }
15493   }
15494
15495   jresult = (void *)result;
15496   return jresult;
15497 }
15498
15499
15500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15501   unsigned int jresult ;
15502   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15503   std::string *arg2 = 0 ;
15504   bool result;
15505
15506   arg1 = (Dali::Property::Key *)jarg1;
15507   if (!jarg2) {
15508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15509     return 0;
15510   }
15511   std::string arg2_str(jarg2);
15512   arg2 = &arg2_str;
15513   {
15514     try {
15515       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15516     } catch (std::out_of_range& e) {
15517       {
15518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15519       };
15520     } catch (std::exception& e) {
15521       {
15522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15523       };
15524     } catch (Dali::DaliException e) {
15525       {
15526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15527       };
15528     } catch (...) {
15529       {
15530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15531       };
15532     }
15533   }
15534
15535   jresult = result;
15536
15537   //argout typemap for const std::string&
15538
15539   return jresult;
15540 }
15541
15542
15543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15544   unsigned int jresult ;
15545   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15546   Dali::Property::Index arg2 ;
15547   bool result;
15548
15549   arg1 = (Dali::Property::Key *)jarg1;
15550   arg2 = (Dali::Property::Index)jarg2;
15551   {
15552     try {
15553       result = (bool)(arg1)->operator ==(arg2);
15554     } catch (std::out_of_range& e) {
15555       {
15556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15557       };
15558     } catch (std::exception& e) {
15559       {
15560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15561       };
15562     } catch (Dali::DaliException e) {
15563       {
15564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15565       };
15566     } catch (...) {
15567       {
15568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15569       };
15570     }
15571   }
15572
15573   jresult = result;
15574   return jresult;
15575 }
15576
15577
15578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15579   unsigned int jresult ;
15580   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15581   Dali::Property::Key *arg2 = 0 ;
15582   bool result;
15583
15584   arg1 = (Dali::Property::Key *)jarg1;
15585   arg2 = (Dali::Property::Key *)jarg2;
15586   if (!arg2) {
15587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15588     return 0;
15589   }
15590   {
15591     try {
15592       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15593     } catch (std::out_of_range& e) {
15594       {
15595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15596       };
15597     } catch (std::exception& e) {
15598       {
15599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15600       };
15601     } catch (Dali::DaliException e) {
15602       {
15603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15604       };
15605     } catch (...) {
15606       {
15607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15608       };
15609     }
15610   }
15611
15612   jresult = result;
15613   return jresult;
15614 }
15615
15616
15617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15618   unsigned int jresult ;
15619   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15620   std::string *arg2 = 0 ;
15621   bool result;
15622
15623   arg1 = (Dali::Property::Key *)jarg1;
15624   if (!jarg2) {
15625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15626     return 0;
15627   }
15628   std::string arg2_str(jarg2);
15629   arg2 = &arg2_str;
15630   {
15631     try {
15632       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15633     } catch (std::out_of_range& e) {
15634       {
15635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15636       };
15637     } catch (std::exception& e) {
15638       {
15639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15640       };
15641     } catch (Dali::DaliException e) {
15642       {
15643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15644       };
15645     } catch (...) {
15646       {
15647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15648       };
15649     }
15650   }
15651
15652   jresult = result;
15653
15654   //argout typemap for const std::string&
15655
15656   return jresult;
15657 }
15658
15659
15660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15661   unsigned int jresult ;
15662   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15663   Dali::Property::Index arg2 ;
15664   bool result;
15665
15666   arg1 = (Dali::Property::Key *)jarg1;
15667   arg2 = (Dali::Property::Index)jarg2;
15668   {
15669     try {
15670       result = (bool)(arg1)->operator !=(arg2);
15671     } catch (std::out_of_range& e) {
15672       {
15673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15674       };
15675     } catch (std::exception& e) {
15676       {
15677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15678       };
15679     } catch (Dali::DaliException e) {
15680       {
15681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15682       };
15683     } catch (...) {
15684       {
15685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15686       };
15687     }
15688   }
15689
15690   jresult = result;
15691   return jresult;
15692 }
15693
15694
15695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15696   unsigned int jresult ;
15697   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15698   Dali::Property::Key *arg2 = 0 ;
15699   bool result;
15700
15701   arg1 = (Dali::Property::Key *)jarg1;
15702   arg2 = (Dali::Property::Key *)jarg2;
15703   if (!arg2) {
15704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15705     return 0;
15706   }
15707   {
15708     try {
15709       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15710     } catch (std::out_of_range& e) {
15711       {
15712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15713       };
15714     } catch (std::exception& e) {
15715       {
15716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15717       };
15718     } catch (Dali::DaliException e) {
15719       {
15720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15721       };
15722     } catch (...) {
15723       {
15724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15725       };
15726     }
15727   }
15728
15729   jresult = result;
15730   return jresult;
15731 }
15732
15733
15734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15735   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15736
15737   arg1 = (Dali::Property::Key *)jarg1;
15738   {
15739     try {
15740       delete arg1;
15741     } catch (std::out_of_range& e) {
15742       {
15743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15744       };
15745     } catch (std::exception& e) {
15746       {
15747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15748       };
15749     } catch (Dali::DaliException e) {
15750       {
15751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15752       };
15753     } catch (...) {
15754       {
15755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15756       };
15757     }
15758   }
15759
15760 }
15761
15762
15763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15764   void * jresult ;
15765   Dali::Property::Map *result = 0 ;
15766
15767   {
15768     try {
15769       result = (Dali::Property::Map *)new Dali::Property::Map();
15770     } catch (std::out_of_range& e) {
15771       {
15772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15773       };
15774     } catch (std::exception& e) {
15775       {
15776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15777       };
15778     } catch (Dali::DaliException e) {
15779       {
15780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15781       };
15782     } catch (...) {
15783       {
15784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15785       };
15786     }
15787   }
15788
15789   jresult = (void *)result;
15790   return jresult;
15791 }
15792
15793
15794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15795   void * jresult ;
15796   Dali::Property::Map *arg1 = 0 ;
15797   Dali::Property::Map *result = 0 ;
15798
15799   arg1 = (Dali::Property::Map *)jarg1;
15800   if (!arg1) {
15801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15802     return 0;
15803   }
15804   {
15805     try {
15806       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15807     } catch (std::out_of_range& e) {
15808       {
15809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15810       };
15811     } catch (std::exception& e) {
15812       {
15813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15814       };
15815     } catch (Dali::DaliException e) {
15816       {
15817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15818       };
15819     } catch (...) {
15820       {
15821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15822       };
15823     }
15824   }
15825
15826   jresult = (void *)result;
15827   return jresult;
15828 }
15829
15830
15831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15832   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15833
15834   arg1 = (Dali::Property::Map *)jarg1;
15835   {
15836     try {
15837       delete arg1;
15838     } catch (std::out_of_range& e) {
15839       {
15840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15841       };
15842     } catch (std::exception& e) {
15843       {
15844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15845       };
15846     } catch (Dali::DaliException e) {
15847       {
15848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15849       };
15850     } catch (...) {
15851       {
15852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15853       };
15854     }
15855   }
15856
15857 }
15858
15859
15860 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15861   unsigned long jresult ;
15862   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15863   Dali::Property::Map::SizeType result;
15864
15865   arg1 = (Dali::Property::Map *)jarg1;
15866   {
15867     try {
15868       result = ((Dali::Property::Map const *)arg1)->Count();
15869     } catch (std::out_of_range& e) {
15870       {
15871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15872       };
15873     } catch (std::exception& e) {
15874       {
15875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15876       };
15877     } catch (Dali::DaliException e) {
15878       {
15879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15880       };
15881     } catch (...) {
15882       {
15883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15884       };
15885     }
15886   }
15887
15888   jresult = (unsigned long)result;
15889   return jresult;
15890 }
15891
15892
15893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15894   unsigned int jresult ;
15895   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15896   bool result;
15897
15898   arg1 = (Dali::Property::Map *)jarg1;
15899   {
15900     try {
15901       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15902     } catch (std::out_of_range& e) {
15903       {
15904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15905       };
15906     } catch (std::exception& e) {
15907       {
15908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15909       };
15910     } catch (Dali::DaliException e) {
15911       {
15912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15913       };
15914     } catch (...) {
15915       {
15916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15917       };
15918     }
15919   }
15920
15921   jresult = result;
15922   return jresult;
15923 }
15924
15925
15926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15927   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15928   char *arg2 = (char *) 0 ;
15929   Dali::Property::Value *arg3 = 0 ;
15930
15931   arg1 = (Dali::Property::Map *)jarg1;
15932   arg2 = (char *)jarg2;
15933   arg3 = (Dali::Property::Value *)jarg3;
15934   if (!arg3) {
15935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15936     return ;
15937   }
15938   {
15939     try {
15940       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15941     } catch (std::out_of_range& e) {
15942       {
15943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15944       };
15945     } catch (std::exception& e) {
15946       {
15947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15948       };
15949     } catch (Dali::DaliException e) {
15950       {
15951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15952       };
15953     } catch (...) {
15954       {
15955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15956       };
15957     }
15958   }
15959
15960 }
15961
15962
15963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15964   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15965   Dali::Property::Index arg2 ;
15966   Dali::Property::Value *arg3 = 0 ;
15967
15968   arg1 = (Dali::Property::Map *)jarg1;
15969   arg2 = (Dali::Property::Index)jarg2;
15970   arg3 = (Dali::Property::Value *)jarg3;
15971   if (!arg3) {
15972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15973     return ;
15974   }
15975   {
15976     try {
15977       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15978     } catch (std::out_of_range& e) {
15979       {
15980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15981       };
15982     } catch (std::exception& e) {
15983       {
15984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15985       };
15986     } catch (Dali::DaliException e) {
15987       {
15988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15989       };
15990     } catch (...) {
15991       {
15992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15993       };
15994     }
15995   }
15996
15997 }
15998
15999
16000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16001   void * jresult ;
16002   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16003   char *arg2 = (char *) 0 ;
16004   Dali::Property::Value *arg3 = 0 ;
16005   Dali::Property::Map *result = 0 ;
16006
16007   arg1 = (Dali::Property::Map *)jarg1;
16008   arg2 = (char *)jarg2;
16009   arg3 = (Dali::Property::Value *)jarg3;
16010   if (!arg3) {
16011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16012     return 0;
16013   }
16014   {
16015     try {
16016       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16017     } catch (std::out_of_range& e) {
16018       {
16019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16020       };
16021     } catch (std::exception& e) {
16022       {
16023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16024       };
16025     } catch (Dali::DaliException e) {
16026       {
16027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16028       };
16029     } catch (...) {
16030       {
16031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16032       };
16033     }
16034   }
16035
16036   jresult = (void *)result;
16037   return jresult;
16038 }
16039
16040
16041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16042   void * jresult ;
16043   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16044   Dali::Property::Index arg2 ;
16045   Dali::Property::Value *arg3 = 0 ;
16046   Dali::Property::Map *result = 0 ;
16047
16048   arg1 = (Dali::Property::Map *)jarg1;
16049   arg2 = (Dali::Property::Index)jarg2;
16050   arg3 = (Dali::Property::Value *)jarg3;
16051   if (!arg3) {
16052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16053     return 0;
16054   }
16055   {
16056     try {
16057       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16058     } catch (std::out_of_range& e) {
16059       {
16060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16061       };
16062     } catch (std::exception& e) {
16063       {
16064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16065       };
16066     } catch (Dali::DaliException e) {
16067       {
16068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16069       };
16070     } catch (...) {
16071       {
16072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16073       };
16074     }
16075   }
16076
16077   jresult = (void *)result;
16078   return jresult;
16079 }
16080
16081
16082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16083   void * jresult ;
16084   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16085   Dali::Property::Map::SizeType arg2 ;
16086   Dali::Property::Value *result = 0 ;
16087
16088   arg1 = (Dali::Property::Map *)jarg1;
16089   arg2 = (Dali::Property::Map::SizeType)jarg2;
16090   {
16091     try {
16092       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16093     } catch (std::out_of_range& e) {
16094       {
16095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16096       };
16097     } catch (std::exception& e) {
16098       {
16099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16100       };
16101     } catch (Dali::DaliException e) {
16102       {
16103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16104       };
16105     } catch (...) {
16106       {
16107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16108       };
16109     }
16110   }
16111
16112   jresult = (void *)result;
16113   return jresult;
16114 }
16115
16116
16117 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16118   char * jresult ;
16119   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16120   Dali::Property::Map::SizeType arg2 ;
16121   std::string *result = 0 ;
16122
16123   arg1 = (Dali::Property::Map *)jarg1;
16124   arg2 = (Dali::Property::Map::SizeType)jarg2;
16125   {
16126     try {
16127       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16128     } catch (std::out_of_range& e) {
16129       {
16130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16131       };
16132     } catch (std::exception& e) {
16133       {
16134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16135       };
16136     } catch (Dali::DaliException e) {
16137       {
16138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16139       };
16140     } catch (...) {
16141       {
16142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16143       };
16144     }
16145   }
16146
16147   jresult = SWIG_csharp_string_callback(result->c_str());
16148   return jresult;
16149 }
16150
16151
16152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16153   void * jresult ;
16154   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16155   Dali::Property::Map::SizeType arg2 ;
16156   SwigValueWrapper< Dali::Property::Key > result;
16157
16158   arg1 = (Dali::Property::Map *)jarg1;
16159   arg2 = (Dali::Property::Map::SizeType)jarg2;
16160   {
16161     try {
16162       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16163     } catch (std::out_of_range& e) {
16164       {
16165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16166       };
16167     } catch (std::exception& e) {
16168       {
16169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16170       };
16171     } catch (Dali::DaliException e) {
16172       {
16173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16174       };
16175     } catch (...) {
16176       {
16177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16178       };
16179     }
16180   }
16181
16182   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16183   return jresult;
16184 }
16185
16186
16187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16188   void * jresult ;
16189   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16190   Dali::Property::Map::SizeType arg2 ;
16191   StringValuePair *result = 0 ;
16192
16193   arg1 = (Dali::Property::Map *)jarg1;
16194   arg2 = (Dali::Property::Map::SizeType)jarg2;
16195   {
16196     try {
16197       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16198     } catch (std::out_of_range& e) {
16199       {
16200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16201       };
16202     } catch (std::exception& e) {
16203       {
16204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16205       };
16206     } catch (Dali::DaliException e) {
16207       {
16208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16209       };
16210     } catch (...) {
16211       {
16212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16213       };
16214     }
16215   }
16216
16217   jresult = (void *)result;
16218   return jresult;
16219 }
16220
16221
16222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16223   void * jresult ;
16224   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16225   char *arg2 = (char *) 0 ;
16226   Dali::Property::Value *result = 0 ;
16227
16228   arg1 = (Dali::Property::Map *)jarg1;
16229   arg2 = (char *)jarg2;
16230   {
16231     try {
16232       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16233     } catch (std::out_of_range& e) {
16234       {
16235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16236       };
16237     } catch (std::exception& e) {
16238       {
16239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16240       };
16241     } catch (Dali::DaliException e) {
16242       {
16243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16244       };
16245     } catch (...) {
16246       {
16247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16248       };
16249     }
16250   }
16251
16252   jresult = (void *)result;
16253   return jresult;
16254 }
16255
16256
16257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16258   void * jresult ;
16259   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16260   Dali::Property::Index arg2 ;
16261   Dali::Property::Value *result = 0 ;
16262
16263   arg1 = (Dali::Property::Map *)jarg1;
16264   arg2 = (Dali::Property::Index)jarg2;
16265   {
16266     try {
16267       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16268     } catch (std::out_of_range& e) {
16269       {
16270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16271       };
16272     } catch (std::exception& e) {
16273       {
16274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16275       };
16276     } catch (Dali::DaliException e) {
16277       {
16278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16279       };
16280     } catch (...) {
16281       {
16282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16283       };
16284     }
16285   }
16286
16287   jresult = (void *)result;
16288   return jresult;
16289 }
16290
16291
16292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16293   void * jresult ;
16294   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16295   Dali::Property::Index arg2 ;
16296   std::string *arg3 = 0 ;
16297   Dali::Property::Value *result = 0 ;
16298
16299   arg1 = (Dali::Property::Map *)jarg1;
16300   arg2 = (Dali::Property::Index)jarg2;
16301   if (!jarg3) {
16302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16303     return 0;
16304   }
16305   std::string arg3_str(jarg3);
16306   arg3 = &arg3_str;
16307   {
16308     try {
16309       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16310     } catch (std::out_of_range& e) {
16311       {
16312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16313       };
16314     } catch (std::exception& e) {
16315       {
16316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16317       };
16318     } catch (Dali::DaliException e) {
16319       {
16320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16321       };
16322     } catch (...) {
16323       {
16324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16325       };
16326     }
16327   }
16328
16329   jresult = (void *)result;
16330
16331   //argout typemap for const std::string&
16332
16333   return jresult;
16334 }
16335
16336
16337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16338   void * jresult ;
16339   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16340   std::string *arg2 = 0 ;
16341   Dali::Property::Type arg3 ;
16342   Dali::Property::Value *result = 0 ;
16343
16344   arg1 = (Dali::Property::Map *)jarg1;
16345   if (!jarg2) {
16346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16347     return 0;
16348   }
16349   std::string arg2_str(jarg2);
16350   arg2 = &arg2_str;
16351   arg3 = (Dali::Property::Type)jarg3;
16352   {
16353     try {
16354       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16355     } catch (std::out_of_range& e) {
16356       {
16357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16358       };
16359     } catch (std::exception& e) {
16360       {
16361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16362       };
16363     } catch (Dali::DaliException e) {
16364       {
16365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16366       };
16367     } catch (...) {
16368       {
16369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16370       };
16371     }
16372   }
16373
16374   jresult = (void *)result;
16375
16376   //argout typemap for const std::string&
16377
16378   return jresult;
16379 }
16380
16381
16382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16383   void * jresult ;
16384   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16385   Dali::Property::Index arg2 ;
16386   Dali::Property::Type arg3 ;
16387   Dali::Property::Value *result = 0 ;
16388
16389   arg1 = (Dali::Property::Map *)jarg1;
16390   arg2 = (Dali::Property::Index)jarg2;
16391   arg3 = (Dali::Property::Type)jarg3;
16392   {
16393     try {
16394       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16395     } catch (std::out_of_range& e) {
16396       {
16397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16398       };
16399     } catch (std::exception& e) {
16400       {
16401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16402       };
16403     } catch (Dali::DaliException e) {
16404       {
16405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16406       };
16407     } catch (...) {
16408       {
16409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16410       };
16411     }
16412   }
16413
16414   jresult = (void *)result;
16415   return jresult;
16416 }
16417
16418
16419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16420   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16421
16422   arg1 = (Dali::Property::Map *)jarg1;
16423   {
16424     try {
16425       (arg1)->Clear();
16426     } catch (std::out_of_range& e) {
16427       {
16428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16429       };
16430     } catch (std::exception& e) {
16431       {
16432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16433       };
16434     } catch (Dali::DaliException e) {
16435       {
16436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16437       };
16438     } catch (...) {
16439       {
16440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16441       };
16442     }
16443   }
16444
16445 }
16446
16447
16448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16449   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16450   Dali::Property::Map *arg2 = 0 ;
16451
16452   arg1 = (Dali::Property::Map *)jarg1;
16453   arg2 = (Dali::Property::Map *)jarg2;
16454   if (!arg2) {
16455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16456     return ;
16457   }
16458   {
16459     try {
16460       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16461     } catch (std::out_of_range& e) {
16462       {
16463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16464       };
16465     } catch (std::exception& e) {
16466       {
16467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16468       };
16469     } catch (Dali::DaliException e) {
16470       {
16471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16472       };
16473     } catch (...) {
16474       {
16475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16476       };
16477     }
16478   }
16479
16480 }
16481
16482
16483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16484   void * jresult ;
16485   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16486   std::string *arg2 = 0 ;
16487   Dali::Property::Value *result = 0 ;
16488
16489   arg1 = (Dali::Property::Map *)jarg1;
16490   if (!jarg2) {
16491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16492     return 0;
16493   }
16494   std::string arg2_str(jarg2);
16495   arg2 = &arg2_str;
16496   {
16497     try {
16498       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16499     } catch (std::out_of_range& e) {
16500       {
16501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16502       };
16503     } catch (std::exception& e) {
16504       {
16505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16506       };
16507     } catch (Dali::DaliException e) {
16508       {
16509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16510       };
16511     } catch (...) {
16512       {
16513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16514       };
16515     }
16516   }
16517
16518   jresult = (void *)result;
16519
16520   //argout typemap for const std::string&
16521
16522   return jresult;
16523 }
16524
16525
16526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16527   void * jresult ;
16528   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16529   Dali::Property::Index arg2 ;
16530   Dali::Property::Value *result = 0 ;
16531
16532   arg1 = (Dali::Property::Map *)jarg1;
16533   arg2 = (Dali::Property::Index)jarg2;
16534   {
16535     try {
16536       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16537     } catch (std::out_of_range& e) {
16538       {
16539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16540       };
16541     } catch (std::exception& e) {
16542       {
16543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16544       };
16545     } catch (Dali::DaliException e) {
16546       {
16547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16548       };
16549     } catch (...) {
16550       {
16551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16552       };
16553     }
16554   }
16555
16556   jresult = (void *)result;
16557   return jresult;
16558 }
16559
16560
16561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16562   void * jresult ;
16563   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16564   Dali::Property::Map *arg2 = 0 ;
16565   Dali::Property::Map *result = 0 ;
16566
16567   arg1 = (Dali::Property::Map *)jarg1;
16568   arg2 = (Dali::Property::Map *)jarg2;
16569   if (!arg2) {
16570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16571     return 0;
16572   }
16573   {
16574     try {
16575       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16576     } catch (std::out_of_range& e) {
16577       {
16578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16579       };
16580     } catch (std::exception& e) {
16581       {
16582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16583       };
16584     } catch (Dali::DaliException e) {
16585       {
16586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16587       };
16588     } catch (...) {
16589       {
16590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16591       };
16592     }
16593   }
16594
16595   jresult = (void *)result;
16596   return jresult;
16597 }
16598
16599
16600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16601
16602   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16603
16604   if (!jarg2) {
16605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16606     return;
16607   }
16608   std::string arg2_str(jarg2);
16609   std::string* arg2 = &arg2_str;
16610
16611   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16612
16613   {
16614     try {
16615       arg1->operator[]((std::string const &)*arg2) = *arg3;
16616     } catch (std::out_of_range& e) {
16617       {
16618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16619       };
16620     } catch (std::exception& e) {
16621       {
16622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16623       };
16624     } catch (Dali::DaliException e) {
16625       {
16626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16627       };
16628     } catch (...) {
16629       {
16630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16631       };
16632     }
16633   }
16634 }
16635
16636
16637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16638
16639   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16640   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16641   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16642
16643   {
16644     try {
16645       arg1->operator[](arg2) = *arg3;
16646     } catch (std::out_of_range& e) {
16647       {
16648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16649       };
16650     } catch (std::exception& e) {
16651       {
16652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16653       };
16654     } catch (Dali::DaliException e) {
16655       {
16656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16657       };
16658     } catch (...) {
16659       {
16660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16661       };
16662     }
16663   }
16664 }
16665
16666
16667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16668   void * jresult ;
16669   Dali::Property::Value *result = 0 ;
16670
16671   {
16672     try {
16673       result = (Dali::Property::Value *)new Dali::Property::Value();
16674     } catch (std::out_of_range& e) {
16675       {
16676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16677       };
16678     } catch (std::exception& e) {
16679       {
16680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16681       };
16682     } catch (Dali::DaliException e) {
16683       {
16684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16685       };
16686     } catch (...) {
16687       {
16688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16689       };
16690     }
16691   }
16692
16693   jresult = (void *)result;
16694   return jresult;
16695 }
16696
16697
16698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16699   void * jresult ;
16700   bool arg1 ;
16701   Dali::Property::Value *result = 0 ;
16702
16703   arg1 = jarg1 ? true : false;
16704   {
16705     try {
16706       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16707     } catch (std::out_of_range& e) {
16708       {
16709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16710       };
16711     } catch (std::exception& e) {
16712       {
16713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16714       };
16715     } catch (Dali::DaliException e) {
16716       {
16717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16718       };
16719     } catch (...) {
16720       {
16721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16722       };
16723     }
16724   }
16725
16726   jresult = (void *)result;
16727   return jresult;
16728 }
16729
16730
16731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16732   void * jresult ;
16733   int arg1 ;
16734   Dali::Property::Value *result = 0 ;
16735
16736   arg1 = (int)jarg1;
16737   {
16738     try {
16739       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16740     } catch (std::out_of_range& e) {
16741       {
16742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16743       };
16744     } catch (std::exception& e) {
16745       {
16746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16747       };
16748     } catch (Dali::DaliException e) {
16749       {
16750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16751       };
16752     } catch (...) {
16753       {
16754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16755       };
16756     }
16757   }
16758
16759   jresult = (void *)result;
16760   return jresult;
16761 }
16762
16763
16764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16765   void * jresult ;
16766   float arg1 ;
16767   Dali::Property::Value *result = 0 ;
16768
16769   arg1 = (float)jarg1;
16770   {
16771     try {
16772       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16773     } catch (std::out_of_range& e) {
16774       {
16775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16776       };
16777     } catch (std::exception& e) {
16778       {
16779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16780       };
16781     } catch (Dali::DaliException e) {
16782       {
16783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16784       };
16785     } catch (...) {
16786       {
16787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16788       };
16789     }
16790   }
16791
16792   jresult = (void *)result;
16793   return jresult;
16794 }
16795
16796
16797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16798   void * jresult ;
16799   Dali::Vector2 *arg1 = 0 ;
16800   Dali::Property::Value *result = 0 ;
16801
16802   arg1 = (Dali::Vector2 *)jarg1;
16803   if (!arg1) {
16804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16805     return 0;
16806   }
16807   {
16808     try {
16809       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16810     } catch (std::out_of_range& e) {
16811       {
16812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16813       };
16814     } catch (std::exception& e) {
16815       {
16816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16817       };
16818     } catch (Dali::DaliException e) {
16819       {
16820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16821       };
16822     } catch (...) {
16823       {
16824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16825       };
16826     }
16827   }
16828
16829   jresult = (void *)result;
16830   return jresult;
16831 }
16832
16833
16834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16835   void * jresult ;
16836   Dali::Vector3 *arg1 = 0 ;
16837   Dali::Property::Value *result = 0 ;
16838
16839   arg1 = (Dali::Vector3 *)jarg1;
16840   if (!arg1) {
16841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16842     return 0;
16843   }
16844   {
16845     try {
16846       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16847     } catch (std::out_of_range& e) {
16848       {
16849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16850       };
16851     } catch (std::exception& e) {
16852       {
16853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16854       };
16855     } catch (Dali::DaliException e) {
16856       {
16857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16858       };
16859     } catch (...) {
16860       {
16861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16862       };
16863     }
16864   }
16865
16866   jresult = (void *)result;
16867   return jresult;
16868 }
16869
16870
16871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16872   void * jresult ;
16873   Dali::Vector4 *arg1 = 0 ;
16874   Dali::Property::Value *result = 0 ;
16875
16876   arg1 = (Dali::Vector4 *)jarg1;
16877   if (!arg1) {
16878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16879     return 0;
16880   }
16881   {
16882     try {
16883       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16884     } catch (std::out_of_range& e) {
16885       {
16886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16887       };
16888     } catch (std::exception& e) {
16889       {
16890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16891       };
16892     } catch (Dali::DaliException e) {
16893       {
16894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16895       };
16896     } catch (...) {
16897       {
16898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16899       };
16900     }
16901   }
16902
16903   jresult = (void *)result;
16904   return jresult;
16905 }
16906
16907
16908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16909   void * jresult ;
16910   Dali::Matrix3 *arg1 = 0 ;
16911   Dali::Property::Value *result = 0 ;
16912
16913   arg1 = (Dali::Matrix3 *)jarg1;
16914   if (!arg1) {
16915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16916     return 0;
16917   }
16918   {
16919     try {
16920       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16921     } catch (std::out_of_range& e) {
16922       {
16923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16924       };
16925     } catch (std::exception& e) {
16926       {
16927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16928       };
16929     } catch (Dali::DaliException e) {
16930       {
16931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16932       };
16933     } catch (...) {
16934       {
16935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16936       };
16937     }
16938   }
16939
16940   jresult = (void *)result;
16941   return jresult;
16942 }
16943
16944
16945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16946   void * jresult ;
16947   Dali::Matrix *arg1 = 0 ;
16948   Dali::Property::Value *result = 0 ;
16949
16950   arg1 = (Dali::Matrix *)jarg1;
16951   if (!arg1) {
16952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16953     return 0;
16954   }
16955   {
16956     try {
16957       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16958     } catch (std::out_of_range& e) {
16959       {
16960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16961       };
16962     } catch (std::exception& e) {
16963       {
16964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16965       };
16966     } catch (Dali::DaliException e) {
16967       {
16968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16969       };
16970     } catch (...) {
16971       {
16972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16973       };
16974     }
16975   }
16976
16977   jresult = (void *)result;
16978   return jresult;
16979 }
16980
16981
16982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16983   void * jresult ;
16984   Dali::Rect< int > *arg1 = 0 ;
16985   Dali::Property::Value *result = 0 ;
16986
16987   arg1 = (Dali::Rect< int > *)jarg1;
16988   if (!arg1) {
16989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16990     return 0;
16991   }
16992   {
16993     try {
16994       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16995     } catch (std::out_of_range& e) {
16996       {
16997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16998       };
16999     } catch (std::exception& e) {
17000       {
17001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17002       };
17003     } catch (Dali::DaliException e) {
17004       {
17005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17006       };
17007     } catch (...) {
17008       {
17009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17010       };
17011     }
17012   }
17013
17014   jresult = (void *)result;
17015   return jresult;
17016 }
17017
17018
17019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17020   void * jresult ;
17021   Dali::AngleAxis *arg1 = 0 ;
17022   Dali::Property::Value *result = 0 ;
17023
17024   arg1 = (Dali::AngleAxis *)jarg1;
17025   if (!arg1) {
17026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17027     return 0;
17028   }
17029   {
17030     try {
17031       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17032     } catch (std::out_of_range& e) {
17033       {
17034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17035       };
17036     } catch (std::exception& e) {
17037       {
17038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17039       };
17040     } catch (Dali::DaliException e) {
17041       {
17042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17043       };
17044     } catch (...) {
17045       {
17046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17047       };
17048     }
17049   }
17050
17051   jresult = (void *)result;
17052   return jresult;
17053 }
17054
17055
17056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17057   void * jresult ;
17058   Dali::Quaternion *arg1 = 0 ;
17059   Dali::Property::Value *result = 0 ;
17060
17061   arg1 = (Dali::Quaternion *)jarg1;
17062   if (!arg1) {
17063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17064     return 0;
17065   }
17066   {
17067     try {
17068       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17069     } catch (std::out_of_range& e) {
17070       {
17071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17072       };
17073     } catch (std::exception& e) {
17074       {
17075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17076       };
17077     } catch (Dali::DaliException e) {
17078       {
17079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17080       };
17081     } catch (...) {
17082       {
17083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17084       };
17085     }
17086   }
17087
17088   jresult = (void *)result;
17089   return jresult;
17090 }
17091
17092
17093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17094   void * jresult ;
17095   std::string *arg1 = 0 ;
17096   Dali::Property::Value *result = 0 ;
17097
17098   if (!jarg1) {
17099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17100     return 0;
17101   }
17102   std::string arg1_str(jarg1);
17103   arg1 = &arg1_str;
17104   {
17105     try {
17106       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17107     } catch (std::out_of_range& e) {
17108       {
17109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17110       };
17111     } catch (std::exception& e) {
17112       {
17113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17114       };
17115     } catch (Dali::DaliException e) {
17116       {
17117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17118       };
17119     } catch (...) {
17120       {
17121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17122       };
17123     }
17124   }
17125
17126   jresult = (void *)result;
17127
17128   //argout typemap for const std::string&
17129
17130   return jresult;
17131 }
17132
17133
17134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17135   void * jresult ;
17136   Dali::Property::Array *arg1 = 0 ;
17137   Dali::Property::Value *result = 0 ;
17138
17139   arg1 = (Dali::Property::Array *)jarg1;
17140   if (!arg1) {
17141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17142     return 0;
17143   }
17144   {
17145     try {
17146       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17147     } catch (std::out_of_range& e) {
17148       {
17149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17150       };
17151     } catch (std::exception& e) {
17152       {
17153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17154       };
17155     } catch (Dali::DaliException e) {
17156       {
17157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17158       };
17159     } catch (...) {
17160       {
17161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17162       };
17163     }
17164   }
17165
17166   jresult = (void *)result;
17167   return jresult;
17168 }
17169
17170
17171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17172   void * jresult ;
17173   Dali::Property::Map *arg1 = 0 ;
17174   Dali::Property::Value *result = 0 ;
17175
17176   arg1 = (Dali::Property::Map *)jarg1;
17177   if (!arg1) {
17178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17179     return 0;
17180   }
17181   {
17182     try {
17183       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17184     } catch (std::out_of_range& e) {
17185       {
17186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17187       };
17188     } catch (std::exception& e) {
17189       {
17190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17191       };
17192     } catch (Dali::DaliException e) {
17193       {
17194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17195       };
17196     } catch (...) {
17197       {
17198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17199       };
17200     }
17201   }
17202
17203   jresult = (void *)result;
17204   return jresult;
17205 }
17206
17207
17208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17209   void * jresult ;
17210   Extents *arg1 = 0 ;
17211   Dali::Property::Value *result = 0 ;
17212
17213   arg1 = (Extents *)jarg1;
17214   if (!arg1) {
17215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17216     return 0;
17217   }
17218   {
17219     try {
17220       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17221     } catch (std::out_of_range& e) {
17222       {
17223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17224       };
17225     } catch (std::exception& e) {
17226       {
17227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17228       };
17229     } catch (...) {
17230       {
17231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17232       };
17233     }
17234   }
17235   jresult = (void *)result;
17236   return jresult;
17237 }
17238
17239
17240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17241   void * jresult ;
17242   Dali::Property::Type arg1 ;
17243   Dali::Property::Value *result = 0 ;
17244
17245   arg1 = (Dali::Property::Type)jarg1;
17246   {
17247     try {
17248       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17249     } catch (std::out_of_range& e) {
17250       {
17251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17252       };
17253     } catch (std::exception& e) {
17254       {
17255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17256       };
17257     } catch (Dali::DaliException e) {
17258       {
17259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17260       };
17261     } catch (...) {
17262       {
17263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17264       };
17265     }
17266   }
17267
17268   jresult = (void *)result;
17269   return jresult;
17270 }
17271
17272
17273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17274   void * jresult ;
17275   Dali::Property::Value *arg1 = 0 ;
17276   Dali::Property::Value *result = 0 ;
17277
17278   arg1 = (Dali::Property::Value *)jarg1;
17279   if (!arg1) {
17280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17281     return 0;
17282   }
17283   {
17284     try {
17285       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17286     } catch (std::out_of_range& e) {
17287       {
17288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17289       };
17290     } catch (std::exception& e) {
17291       {
17292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17293       };
17294     } catch (Dali::DaliException e) {
17295       {
17296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17297       };
17298     } catch (...) {
17299       {
17300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17301       };
17302     }
17303   }
17304
17305   jresult = (void *)result;
17306   return jresult;
17307 }
17308
17309
17310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17311   void * jresult ;
17312   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17313   Dali::Property::Value *arg2 = 0 ;
17314   Dali::Property::Value *result = 0 ;
17315
17316   arg1 = (Dali::Property::Value *)jarg1;
17317   arg2 = (Dali::Property::Value *)jarg2;
17318   if (!arg2) {
17319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17320     return 0;
17321   }
17322   {
17323     try {
17324       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17325     } catch (std::out_of_range& e) {
17326       {
17327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17328       };
17329     } catch (std::exception& e) {
17330       {
17331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17332       };
17333     } catch (Dali::DaliException e) {
17334       {
17335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17336       };
17337     } catch (...) {
17338       {
17339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17340       };
17341     }
17342   }
17343
17344   jresult = (void *)result;
17345   return jresult;
17346 }
17347
17348
17349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17350   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17351
17352   arg1 = (Dali::Property::Value *)jarg1;
17353   {
17354     try {
17355       delete arg1;
17356     } catch (std::out_of_range& e) {
17357       {
17358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17359       };
17360     } catch (std::exception& e) {
17361       {
17362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17363       };
17364     } catch (Dali::DaliException e) {
17365       {
17366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17367       };
17368     } catch (...) {
17369       {
17370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17371       };
17372     }
17373   }
17374
17375 }
17376
17377
17378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17379   int jresult ;
17380   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17381   Dali::Property::Type result;
17382
17383   arg1 = (Dali::Property::Value *)jarg1;
17384   {
17385     try {
17386       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17387     } catch (std::out_of_range& e) {
17388       {
17389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17390       };
17391     } catch (std::exception& e) {
17392       {
17393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17394       };
17395     } catch (Dali::DaliException e) {
17396       {
17397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17398       };
17399     } catch (...) {
17400       {
17401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17402       };
17403     }
17404   }
17405
17406   jresult = (int)result;
17407   return jresult;
17408 }
17409
17410
17411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17412   unsigned int jresult ;
17413   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17414   bool *arg2 = 0 ;
17415   bool result;
17416
17417   arg1 = (Dali::Property::Value *)jarg1;
17418   arg2 = (bool *)jarg2;
17419   {
17420     try {
17421       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17422     } catch (std::out_of_range& e) {
17423       {
17424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17425       };
17426     } catch (std::exception& e) {
17427       {
17428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17429       };
17430     } catch (Dali::DaliException e) {
17431       {
17432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17433       };
17434     } catch (...) {
17435       {
17436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17437       };
17438     }
17439   }
17440
17441   jresult = result;
17442   return jresult;
17443 }
17444
17445
17446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17447   unsigned int jresult ;
17448   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17449   float *arg2 = 0 ;
17450   bool result;
17451
17452   arg1 = (Dali::Property::Value *)jarg1;
17453   arg2 = (float *)jarg2;
17454   {
17455     try {
17456       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17457     } catch (std::out_of_range& e) {
17458       {
17459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17460       };
17461     } catch (std::exception& e) {
17462       {
17463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17464       };
17465     } catch (Dali::DaliException e) {
17466       {
17467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17468       };
17469     } catch (...) {
17470       {
17471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17472       };
17473     }
17474   }
17475
17476   jresult = result;
17477   return jresult;
17478 }
17479
17480
17481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17482   unsigned int jresult ;
17483   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17484   int *arg2 = 0 ;
17485   bool result;
17486
17487   arg1 = (Dali::Property::Value *)jarg1;
17488   arg2 = (int *)jarg2;
17489   {
17490     try {
17491       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17492     } catch (std::out_of_range& e) {
17493       {
17494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17495       };
17496     } catch (std::exception& e) {
17497       {
17498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17499       };
17500     } catch (Dali::DaliException e) {
17501       {
17502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17503       };
17504     } catch (...) {
17505       {
17506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17507       };
17508     }
17509   }
17510
17511   jresult = result;
17512   return jresult;
17513 }
17514
17515
17516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17517   unsigned int jresult ;
17518   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17519   Dali::Rect< int > *arg2 = 0 ;
17520   bool result;
17521
17522   arg1 = (Dali::Property::Value *)jarg1;
17523   arg2 = (Dali::Rect< int > *)jarg2;
17524   if (!arg2) {
17525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17526     return 0;
17527   }
17528   {
17529     try {
17530       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17531     } catch (std::out_of_range& e) {
17532       {
17533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17534       };
17535     } catch (std::exception& e) {
17536       {
17537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17538       };
17539     } catch (Dali::DaliException e) {
17540       {
17541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17542       };
17543     } catch (...) {
17544       {
17545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17546       };
17547     }
17548   }
17549
17550   jresult = result;
17551   return jresult;
17552 }
17553
17554
17555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17556   unsigned int jresult ;
17557   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17558   Dali::Vector2 *arg2 = 0 ;
17559   bool result;
17560
17561   arg1 = (Dali::Property::Value *)jarg1;
17562   arg2 = (Dali::Vector2 *)jarg2;
17563   if (!arg2) {
17564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17565     return 0;
17566   }
17567   {
17568     try {
17569       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17570     } catch (std::out_of_range& e) {
17571       {
17572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17573       };
17574     } catch (std::exception& e) {
17575       {
17576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17577       };
17578     } catch (Dali::DaliException e) {
17579       {
17580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17581       };
17582     } catch (...) {
17583       {
17584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17585       };
17586     }
17587   }
17588
17589   jresult = result;
17590   return jresult;
17591 }
17592
17593
17594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17595   unsigned int jresult ;
17596   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17597   Dali::Vector3 *arg2 = 0 ;
17598   bool result;
17599
17600   arg1 = (Dali::Property::Value *)jarg1;
17601   arg2 = (Dali::Vector3 *)jarg2;
17602   if (!arg2) {
17603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17604     return 0;
17605   }
17606   {
17607     try {
17608       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17609     } catch (std::out_of_range& e) {
17610       {
17611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17612       };
17613     } catch (std::exception& e) {
17614       {
17615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17616       };
17617     } catch (Dali::DaliException e) {
17618       {
17619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17620       };
17621     } catch (...) {
17622       {
17623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17624       };
17625     }
17626   }
17627
17628   jresult = result;
17629   return jresult;
17630 }
17631
17632
17633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17634   unsigned int jresult ;
17635   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17636   Dali::Vector4 *arg2 = 0 ;
17637   bool result;
17638
17639   arg1 = (Dali::Property::Value *)jarg1;
17640   arg2 = (Dali::Vector4 *)jarg2;
17641   if (!arg2) {
17642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17643     return 0;
17644   }
17645   {
17646     try {
17647       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17648     } catch (std::out_of_range& e) {
17649       {
17650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17651       };
17652     } catch (std::exception& e) {
17653       {
17654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17655       };
17656     } catch (Dali::DaliException e) {
17657       {
17658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17659       };
17660     } catch (...) {
17661       {
17662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17663       };
17664     }
17665   }
17666
17667   jresult = result;
17668   return jresult;
17669 }
17670
17671
17672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17673   unsigned int jresult ;
17674   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17675   Dali::Matrix3 *arg2 = 0 ;
17676   bool result;
17677
17678   arg1 = (Dali::Property::Value *)jarg1;
17679   arg2 = (Dali::Matrix3 *)jarg2;
17680   if (!arg2) {
17681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17682     return 0;
17683   }
17684   {
17685     try {
17686       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17687     } catch (std::out_of_range& e) {
17688       {
17689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17690       };
17691     } catch (std::exception& e) {
17692       {
17693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17694       };
17695     } catch (Dali::DaliException e) {
17696       {
17697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17698       };
17699     } catch (...) {
17700       {
17701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17702       };
17703     }
17704   }
17705
17706   jresult = result;
17707   return jresult;
17708 }
17709
17710
17711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17712   unsigned int jresult ;
17713   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17714   Dali::Matrix *arg2 = 0 ;
17715   bool result;
17716
17717   arg1 = (Dali::Property::Value *)jarg1;
17718   arg2 = (Dali::Matrix *)jarg2;
17719   if (!arg2) {
17720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17721     return 0;
17722   }
17723   {
17724     try {
17725       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17726     } catch (std::out_of_range& e) {
17727       {
17728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17729       };
17730     } catch (std::exception& e) {
17731       {
17732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17733       };
17734     } catch (Dali::DaliException e) {
17735       {
17736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17737       };
17738     } catch (...) {
17739       {
17740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17741       };
17742     }
17743   }
17744
17745   jresult = result;
17746   return jresult;
17747 }
17748
17749
17750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17751   unsigned int jresult ;
17752   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17753   Dali::AngleAxis *arg2 = 0 ;
17754   bool result;
17755
17756   arg1 = (Dali::Property::Value *)jarg1;
17757   arg2 = (Dali::AngleAxis *)jarg2;
17758   if (!arg2) {
17759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17760     return 0;
17761   }
17762   {
17763     try {
17764       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17765     } catch (std::out_of_range& e) {
17766       {
17767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17768       };
17769     } catch (std::exception& e) {
17770       {
17771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17772       };
17773     } catch (Dali::DaliException e) {
17774       {
17775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17776       };
17777     } catch (...) {
17778       {
17779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17780       };
17781     }
17782   }
17783
17784   jresult = result;
17785   return jresult;
17786 }
17787
17788
17789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17790   unsigned int jresult ;
17791   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17792   Dali::Quaternion *arg2 = 0 ;
17793   bool result;
17794
17795   arg1 = (Dali::Property::Value *)jarg1;
17796   arg2 = (Dali::Quaternion *)jarg2;
17797   if (!arg2) {
17798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17799     return 0;
17800   }
17801   {
17802     try {
17803       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17804     } catch (std::out_of_range& e) {
17805       {
17806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17807       };
17808     } catch (std::exception& e) {
17809       {
17810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17811       };
17812     } catch (Dali::DaliException e) {
17813       {
17814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17815       };
17816     } catch (...) {
17817       {
17818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17819       };
17820     }
17821   }
17822
17823   jresult = result;
17824   return jresult;
17825 }
17826
17827
17828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17829   unsigned int jresult ;
17830   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17831   std::string *arg2 = 0 ;
17832   bool result;
17833
17834   arg1 = (Dali::Property::Value *)jarg1;
17835
17836   //typemap in
17837   std::string temp;
17838   arg2 = &temp;
17839
17840   {
17841     try {
17842       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17843     } catch (std::out_of_range& e) {
17844       {
17845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17846       };
17847     } catch (std::exception& e) {
17848       {
17849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17850       };
17851     } catch (Dali::DaliException e) {
17852       {
17853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17854       };
17855     } catch (...) {
17856       {
17857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17858       };
17859     }
17860   }
17861
17862   jresult = result;
17863
17864   //Typemap argout in c++ file.
17865   //This will convert c++ string to c# string
17866   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17867
17868   return jresult;
17869 }
17870
17871
17872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17873   unsigned int jresult ;
17874   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17875   Dali::Property::Array *arg2 = 0 ;
17876   bool result;
17877
17878   arg1 = (Dali::Property::Value *)jarg1;
17879   arg2 = (Dali::Property::Array *)jarg2;
17880   if (!arg2) {
17881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17882     return 0;
17883   }
17884   {
17885     try {
17886       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17887     } catch (std::out_of_range& e) {
17888       {
17889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17890       };
17891     } catch (std::exception& e) {
17892       {
17893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17894       };
17895     } catch (Dali::DaliException e) {
17896       {
17897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17898       };
17899     } catch (...) {
17900       {
17901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17902       };
17903     }
17904   }
17905
17906   jresult = result;
17907   return jresult;
17908 }
17909
17910
17911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17912   unsigned int jresult ;
17913   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17914   Dali::Property::Map *arg2 = 0 ;
17915   bool result;
17916
17917   arg1 = (Dali::Property::Value *)jarg1;
17918   arg2 = (Dali::Property::Map *)jarg2;
17919   if (!arg2) {
17920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17921     return 0;
17922   }
17923   {
17924     try {
17925       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17926     } catch (std::out_of_range& e) {
17927       {
17928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17929       };
17930     } catch (std::exception& e) {
17931       {
17932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17933       };
17934     } catch (Dali::DaliException e) {
17935       {
17936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17937       };
17938     } catch (...) {
17939       {
17940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17941       };
17942     }
17943   }
17944
17945   jresult = result;
17946   return jresult;
17947 }
17948
17949
17950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17951   unsigned int jresult ;
17952   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17953   Extents *arg2 = 0 ;
17954   bool result;
17955
17956   arg1 = (Dali::Property::Value *)jarg1;
17957   arg2 = (Extents *)jarg2;
17958   if (!arg2) {
17959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17960     return 0;
17961   }
17962   {
17963     try {
17964       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17965     } catch (std::out_of_range& e) {
17966       {
17967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17968       };
17969     } catch (std::exception& e) {
17970       {
17971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17972       };
17973     } catch (...) {
17974       {
17975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17976       };
17977     }
17978   }
17979   jresult = result;
17980   return jresult;
17981 }
17982
17983
17984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17985   void * jresult ;
17986   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17987   Dali::Property::Array *result = 0 ;
17988
17989   arg1 = (Dali::Property::Value *)jarg1;
17990   {
17991     try {
17992       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17993     } catch (std::out_of_range& e) {
17994       {
17995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17996       };
17997     } catch (std::exception& e) {
17998       {
17999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18000       };
18001     } catch (Dali::DaliException e) {
18002       {
18003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18004       };
18005     } catch (...) {
18006       {
18007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18008       };
18009     }
18010   }
18011
18012   jresult = (void *)result;
18013   return jresult;
18014 }
18015
18016
18017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18018   void * jresult ;
18019   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18020   Dali::Property::Map *result = 0 ;
18021
18022   arg1 = (Dali::Property::Value *)jarg1;
18023   {
18024     try {
18025       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18026     } catch (std::out_of_range& e) {
18027       {
18028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18029       };
18030     } catch (std::exception& e) {
18031       {
18032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18033       };
18034     } catch (Dali::DaliException e) {
18035       {
18036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18037       };
18038     } catch (...) {
18039       {
18040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18041       };
18042     }
18043   }
18044
18045   jresult = (void *)result;
18046   return jresult;
18047 }
18048
18049
18050 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18051   char * jresult ;
18052   Dali::Property::Type arg1 ;
18053   char *result = 0 ;
18054
18055   arg1 = (Dali::Property::Type)jarg1;
18056   {
18057     try {
18058       result = (char *)Dali::PropertyTypes::GetName(arg1);
18059     } catch (std::out_of_range& e) {
18060       {
18061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18062       };
18063     } catch (std::exception& e) {
18064       {
18065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18066       };
18067     } catch (Dali::DaliException e) {
18068       {
18069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18070       };
18071     } catch (...) {
18072       {
18073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18074       };
18075     }
18076   }
18077
18078   jresult = SWIG_csharp_string_callback((const char *)result);
18079   return jresult;
18080 }
18081
18082
18083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18084   unsigned int jresult ;
18085   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18086   std::string *arg2 = 0 ;
18087   Dali::Property::Map *arg3 = 0 ;
18088   bool result;
18089
18090   arg1 = (Dali::BaseObject *)jarg1;
18091   if (!jarg2) {
18092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18093     return 0;
18094   }
18095   std::string arg2_str(jarg2);
18096   arg2 = &arg2_str;
18097   arg3 = (Dali::Property::Map *)jarg3;
18098   if (!arg3) {
18099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18100     return 0;
18101   }
18102   {
18103     try {
18104       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18105     } catch (std::out_of_range& e) {
18106       {
18107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18108       };
18109     } catch (std::exception& e) {
18110       {
18111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18112       };
18113     } catch (Dali::DaliException e) {
18114       {
18115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18116       };
18117     } catch (...) {
18118       {
18119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18120       };
18121     }
18122   }
18123
18124   jresult = result;
18125
18126   //argout typemap for const std::string&
18127
18128   return jresult;
18129 }
18130
18131
18132 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18133   char * jresult ;
18134   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18135   std::string *result = 0 ;
18136
18137   arg1 = (Dali::BaseObject *)jarg1;
18138   {
18139     try {
18140       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18141     } catch (std::out_of_range& e) {
18142       {
18143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18144       };
18145     } catch (std::exception& e) {
18146       {
18147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18148       };
18149     } catch (Dali::DaliException e) {
18150       {
18151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18152       };
18153     } catch (...) {
18154       {
18155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18156       };
18157     }
18158   }
18159
18160   jresult = SWIG_csharp_string_callback(result->c_str());
18161   return jresult;
18162 }
18163
18164
18165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18166   unsigned int jresult ;
18167   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18168   Dali::TypeInfo *arg2 = 0 ;
18169   bool result;
18170
18171   arg1 = (Dali::BaseObject *)jarg1;
18172   arg2 = (Dali::TypeInfo *)jarg2;
18173   if (!arg2) {
18174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18175     return 0;
18176   }
18177   {
18178     try {
18179       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18180     } catch (std::out_of_range& e) {
18181       {
18182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18183       };
18184     } catch (std::exception& e) {
18185       {
18186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18187       };
18188     } catch (Dali::DaliException e) {
18189       {
18190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18191       };
18192     } catch (...) {
18193       {
18194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18195       };
18196     }
18197   }
18198
18199   jresult = result;
18200   return jresult;
18201 }
18202
18203
18204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18205   unsigned int jresult ;
18206   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18207   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18208   std::string *arg3 = 0 ;
18209   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18210   bool result;
18211
18212   arg1 = (Dali::BaseObject *)jarg1;
18213   arg2 = (ConnectionTrackerInterface *)jarg2;
18214   if (!jarg3) {
18215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18216     return 0;
18217   }
18218   std::string arg3_str(jarg3);
18219   arg3 = &arg3_str;
18220   arg4 = (FunctorDelegate *)jarg4;
18221   {
18222     try {
18223       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18224     } catch (std::out_of_range& e) {
18225       {
18226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18227       };
18228     } catch (std::exception& e) {
18229       {
18230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18231       };
18232     } catch (Dali::DaliException e) {
18233       {
18234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18235       };
18236     } catch (...) {
18237       {
18238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18239       };
18240     }
18241   }
18242
18243   jresult = result;
18244
18245   //argout typemap for const std::string&
18246
18247   return jresult;
18248 }
18249
18250
18251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18252   void * jresult ;
18253   Dali::BaseHandle *arg1 = 0 ;
18254   Dali::BaseObject *result = 0 ;
18255
18256   arg1 = (Dali::BaseHandle *)jarg1;
18257   if (!arg1) {
18258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18259     return 0;
18260   }
18261   {
18262     try {
18263       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18264     } catch (std::out_of_range& e) {
18265       {
18266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18267       };
18268     } catch (std::exception& e) {
18269       {
18270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18271       };
18272     } catch (Dali::DaliException e) {
18273       {
18274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18275       };
18276     } catch (...) {
18277       {
18278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18279       };
18280     }
18281   }
18282
18283   jresult = (void *)result;
18284   return jresult;
18285 }
18286
18287
18288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18289   void * jresult ;
18290   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18291   Dali::BaseHandle *result = 0 ;
18292
18293   arg1 = (Dali::BaseObject *)jarg1;
18294   {
18295     try {
18296       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18297     } catch (std::out_of_range& e) {
18298       {
18299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18300       };
18301     } catch (std::exception& e) {
18302       {
18303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18304       };
18305     } catch (Dali::DaliException e) {
18306       {
18307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18308       };
18309     } catch (...) {
18310       {
18311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18312       };
18313     }
18314   }
18315
18316   jresult = (void *)result;
18317   return jresult;
18318 }
18319
18320
18321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18322   void * jresult ;
18323   Dali::BaseHandle *result = 0 ;
18324
18325   {
18326     try {
18327       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18328     } catch (std::out_of_range& e) {
18329       {
18330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18331       };
18332     } catch (std::exception& e) {
18333       {
18334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18335       };
18336     } catch (Dali::DaliException e) {
18337       {
18338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18339       };
18340     } catch (...) {
18341       {
18342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18343       };
18344     }
18345   }
18346
18347   jresult = (void *)result;
18348   return jresult;
18349 }
18350
18351
18352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18353   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18354
18355   arg1 = (Dali::BaseHandle *)jarg1;
18356   {
18357     try {
18358       delete arg1;
18359     } catch (std::out_of_range& e) {
18360       {
18361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18362       };
18363     } catch (std::exception& e) {
18364       {
18365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18366       };
18367     } catch (Dali::DaliException e) {
18368       {
18369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18370       };
18371     } catch (...) {
18372       {
18373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18374       };
18375     }
18376   }
18377
18378 }
18379
18380
18381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18382   void * jresult ;
18383   Dali::BaseHandle *arg1 = 0 ;
18384   Dali::BaseHandle *result = 0 ;
18385
18386   arg1 = (Dali::BaseHandle *)jarg1;
18387   if (!arg1) {
18388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18389     return 0;
18390   }
18391   {
18392     try {
18393       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18394     } catch (std::out_of_range& e) {
18395       {
18396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18397       };
18398     } catch (std::exception& e) {
18399       {
18400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18401       };
18402     } catch (Dali::DaliException e) {
18403       {
18404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18405       };
18406     } catch (...) {
18407       {
18408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18409       };
18410     }
18411   }
18412
18413   jresult = (void *)result;
18414   return jresult;
18415 }
18416
18417
18418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18419   void * jresult ;
18420   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18421   Dali::BaseHandle *arg2 = 0 ;
18422   Dali::BaseHandle *result = 0 ;
18423
18424   arg1 = (Dali::BaseHandle *)jarg1;
18425   arg2 = (Dali::BaseHandle *)jarg2;
18426   if (!arg2) {
18427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18428     return 0;
18429   }
18430   {
18431     try {
18432       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18433     } catch (std::out_of_range& e) {
18434       {
18435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18436       };
18437     } catch (std::exception& e) {
18438       {
18439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18440       };
18441     } catch (Dali::DaliException e) {
18442       {
18443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18444       };
18445     } catch (...) {
18446       {
18447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18448       };
18449     }
18450   }
18451
18452   jresult = (void *)result;
18453   return jresult;
18454 }
18455
18456
18457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18458   unsigned int jresult ;
18459   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18460   std::string *arg2 = 0 ;
18461   Dali::Property::Map *arg3 = 0 ;
18462   bool result;
18463
18464   arg1 = (Dali::BaseHandle *)jarg1;
18465   if (!jarg2) {
18466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18467     return 0;
18468   }
18469   std::string arg2_str(jarg2);
18470   arg2 = &arg2_str;
18471   arg3 = (Dali::Property::Map *)jarg3;
18472   if (!arg3) {
18473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18474     return 0;
18475   }
18476   {
18477     try {
18478       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18479     } catch (std::out_of_range& e) {
18480       {
18481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18482       };
18483     } catch (std::exception& e) {
18484       {
18485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18486       };
18487     } catch (Dali::DaliException e) {
18488       {
18489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18490       };
18491     } catch (...) {
18492       {
18493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18494       };
18495     }
18496   }
18497
18498   jresult = result;
18499
18500   //argout typemap for const std::string&
18501
18502   return jresult;
18503 }
18504
18505
18506 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18507   char * jresult ;
18508   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18509   std::string *result = 0 ;
18510
18511   arg1 = (Dali::BaseHandle *)jarg1;
18512   {
18513     try {
18514       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18515     } catch (std::out_of_range& e) {
18516       {
18517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18518       };
18519     } catch (std::exception& e) {
18520       {
18521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18522       };
18523     } catch (Dali::DaliException e) {
18524       {
18525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18526       };
18527     } catch (...) {
18528       {
18529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18530       };
18531     }
18532   }
18533
18534   jresult = SWIG_csharp_string_callback(result->c_str());
18535   return jresult;
18536 }
18537
18538
18539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18540   unsigned int jresult ;
18541   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18542   Dali::TypeInfo *arg2 = 0 ;
18543   bool result;
18544
18545   arg1 = (Dali::BaseHandle *)jarg1;
18546   arg2 = (Dali::TypeInfo *)jarg2;
18547   if (!arg2) {
18548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18549     return 0;
18550   }
18551   {
18552     try {
18553       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18554     } catch (std::out_of_range& e) {
18555       {
18556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18557       };
18558     } catch (std::exception& e) {
18559       {
18560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18561       };
18562     } catch (Dali::DaliException e) {
18563       {
18564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18565       };
18566     } catch (...) {
18567       {
18568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18569       };
18570     }
18571   }
18572
18573   jresult = result;
18574   return jresult;
18575 }
18576
18577
18578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18579   void * jresult ;
18580   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18581   Dali::BaseObject *result = 0 ;
18582
18583   arg1 = (Dali::BaseHandle *)jarg1;
18584   {
18585     try {
18586       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18587     } catch (std::out_of_range& e) {
18588       {
18589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18590       };
18591     } catch (std::exception& e) {
18592       {
18593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18594       };
18595     } catch (Dali::DaliException e) {
18596       {
18597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18598       };
18599     } catch (...) {
18600       {
18601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18602       };
18603     }
18604   }
18605
18606   jresult = (void *)result;
18607   return jresult;
18608 }
18609
18610
18611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18612   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18613
18614   arg1 = (Dali::BaseHandle *)jarg1;
18615   {
18616     try {
18617       (arg1)->Reset();
18618     } catch (std::out_of_range& e) {
18619       {
18620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18621       };
18622     } catch (std::exception& e) {
18623       {
18624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18625       };
18626     } catch (Dali::DaliException e) {
18627       {
18628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18629       };
18630     } catch (...) {
18631       {
18632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18633       };
18634     }
18635   }
18636
18637 }
18638
18639
18640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18641   unsigned int jresult ;
18642   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18643   Dali::BaseHandle *arg2 = 0 ;
18644   bool result;
18645
18646   arg1 = (Dali::BaseHandle *)jarg1;
18647   arg2 = (Dali::BaseHandle *)jarg2;
18648   if (!arg2) {
18649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18650     return 0;
18651   }
18652   {
18653     try {
18654       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18655     } catch (std::out_of_range& e) {
18656       {
18657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18658       };
18659     } catch (std::exception& e) {
18660       {
18661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18662       };
18663     } catch (Dali::DaliException e) {
18664       {
18665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18666       };
18667     } catch (...) {
18668       {
18669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18670       };
18671     }
18672   }
18673
18674   jresult = result;
18675   return jresult;
18676 }
18677
18678
18679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18680   unsigned int jresult ;
18681   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18682   Dali::BaseHandle *arg2 = 0 ;
18683   bool result;
18684
18685   arg1 = (Dali::BaseHandle *)jarg1;
18686   arg2 = (Dali::BaseHandle *)jarg2;
18687   if (!arg2) {
18688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18689     return 0;
18690   }
18691   {
18692     try {
18693       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18694     } catch (std::out_of_range& e) {
18695       {
18696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18697       };
18698     } catch (std::exception& e) {
18699       {
18700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18701       };
18702     } catch (Dali::DaliException e) {
18703       {
18704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18705       };
18706     } catch (...) {
18707       {
18708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18709       };
18710     }
18711   }
18712
18713   jresult = result;
18714   return jresult;
18715 }
18716
18717
18718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18719   void * jresult ;
18720   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18721   Dali::RefObject *result = 0 ;
18722
18723   arg1 = (Dali::BaseHandle *)jarg1;
18724   {
18725     try {
18726       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18727     } catch (std::out_of_range& e) {
18728       {
18729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18730       };
18731     } catch (std::exception& e) {
18732       {
18733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18734       };
18735     } catch (Dali::DaliException e) {
18736       {
18737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18738       };
18739     } catch (...) {
18740       {
18741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18742       };
18743     }
18744   }
18745
18746   jresult = (void *)result;
18747   return jresult;
18748 }
18749
18750
18751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18752   unsigned int jresult ;
18753   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18754   bool result;
18755
18756   arg1 = (Dali::BaseHandle *)jarg1;
18757   {
18758     try {
18759       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18760     } catch (std::out_of_range& e) {
18761       {
18762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18763       };
18764     } catch (std::exception& e) {
18765       {
18766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18767       };
18768     } catch (Dali::DaliException e) {
18769       {
18770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18771       };
18772     } catch (...) {
18773       {
18774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18775       };
18776     }
18777   }
18778
18779   jresult = result;
18780   return jresult;
18781 }
18782
18783
18784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18785   unsigned int jresult ;
18786   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18787   Dali::BaseHandle *arg2 = 0 ;
18788   bool result;
18789
18790   arg1 = (Dali::BaseHandle *)jarg1;
18791   arg2 = (Dali::BaseHandle *)jarg2;
18792   if (!arg2) {
18793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18794     return 0;
18795   }
18796   {
18797     try {
18798       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18799     } catch (std::out_of_range& e) {
18800       {
18801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18802       };
18803     } catch (std::exception& e) {
18804       {
18805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18806       };
18807     } catch (Dali::DaliException e) {
18808       {
18809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18810       };
18811     } catch (...) {
18812       {
18813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18814       };
18815     }
18816   }
18817
18818   jresult = result;
18819   return jresult;
18820 }
18821
18822
18823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18824   unsigned int jresult ;
18825   Dali::BaseHandle *arg1 = 0 ;
18826   Dali::BaseHandle *arg2 = 0 ;
18827   bool result;
18828
18829   arg1 = (Dali::BaseHandle *)jarg1;
18830   if (!arg1) {
18831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18832     return 0;
18833   }
18834   arg2 = (Dali::BaseHandle *)jarg2;
18835   if (!arg2) {
18836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18837     return 0;
18838   }
18839   {
18840     try {
18841       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18842     } catch (std::out_of_range& e) {
18843       {
18844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18845       };
18846     } catch (std::exception& e) {
18847       {
18848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18849       };
18850     } catch (Dali::DaliException e) {
18851       {
18852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18853       };
18854     } catch (...) {
18855       {
18856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18857       };
18858     }
18859   }
18860
18861   jresult = result;
18862   return jresult;
18863 }
18864
18865
18866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18867   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18868
18869   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18870   {
18871     try {
18872       delete arg1;
18873     } catch (std::out_of_range& e) {
18874       {
18875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18876       };
18877     } catch (std::exception& e) {
18878       {
18879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18880       };
18881     } catch (Dali::DaliException e) {
18882       {
18883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18884       };
18885     } catch (...) {
18886       {
18887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18888       };
18889     }
18890   }
18891
18892 }
18893
18894
18895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18896   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18897   SlotObserver *arg2 = (SlotObserver *) 0 ;
18898   CallbackBase *arg3 = (CallbackBase *) 0 ;
18899
18900   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18901   arg2 = (SlotObserver *)jarg2;
18902   arg3 = (CallbackBase *)jarg3;
18903   {
18904     try {
18905       (arg1)->SignalConnected(arg2,arg3);
18906     } catch (std::out_of_range& e) {
18907       {
18908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18909       };
18910     } catch (std::exception& e) {
18911       {
18912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18913       };
18914     } catch (Dali::DaliException e) {
18915       {
18916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18917       };
18918     } catch (...) {
18919       {
18920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18921       };
18922     }
18923   }
18924
18925 }
18926
18927
18928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18929   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18930
18931   arg1 = (Dali::SignalObserver *)jarg1;
18932   {
18933     try {
18934       delete arg1;
18935     } catch (std::out_of_range& e) {
18936       {
18937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18938       };
18939     } catch (std::exception& e) {
18940       {
18941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18942       };
18943     } catch (Dali::DaliException e) {
18944       {
18945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18946       };
18947     } catch (...) {
18948       {
18949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18950       };
18951     }
18952   }
18953
18954 }
18955
18956
18957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18958   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18959   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18960   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18961
18962   arg1 = (Dali::SignalObserver *)jarg1;
18963   arg2 = (Dali::SlotObserver *)jarg2;
18964   arg3 = (Dali::CallbackBase *)jarg3;
18965   {
18966     try {
18967       (arg1)->SignalDisconnected(arg2,arg3);
18968     } catch (std::out_of_range& e) {
18969       {
18970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18971       };
18972     } catch (std::exception& e) {
18973       {
18974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18975       };
18976     } catch (Dali::DaliException e) {
18977       {
18978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18979       };
18980     } catch (...) {
18981       {
18982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18983       };
18984     }
18985   }
18986
18987 }
18988
18989
18990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18991   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18992
18993   arg1 = (Dali::SlotObserver *)jarg1;
18994   {
18995     try {
18996       delete arg1;
18997     } catch (std::out_of_range& e) {
18998       {
18999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19000       };
19001     } catch (std::exception& e) {
19002       {
19003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19004       };
19005     } catch (Dali::DaliException e) {
19006       {
19007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19008       };
19009     } catch (...) {
19010       {
19011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19012       };
19013     }
19014   }
19015
19016 }
19017
19018
19019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19020   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19021   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19022
19023   arg1 = (Dali::SlotObserver *)jarg1;
19024   arg2 = (Dali::CallbackBase *)jarg2;
19025   {
19026     try {
19027       (arg1)->SlotDisconnected(arg2);
19028     } catch (std::out_of_range& e) {
19029       {
19030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19031       };
19032     } catch (std::exception& e) {
19033       {
19034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19035       };
19036     } catch (Dali::DaliException e) {
19037       {
19038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19039       };
19040     } catch (...) {
19041       {
19042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19043       };
19044     }
19045   }
19046
19047 }
19048
19049
19050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19051   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19052
19053   arg1 = (Dali::ConnectionTracker *)jarg1;
19054   {
19055     try {
19056       delete arg1;
19057     } catch (std::out_of_range& e) {
19058       {
19059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19060       };
19061     } catch (std::exception& e) {
19062       {
19063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19064       };
19065     } catch (Dali::DaliException e) {
19066       {
19067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19068       };
19069     } catch (...) {
19070       {
19071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19072       };
19073     }
19074   }
19075
19076 }
19077
19078
19079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19080   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19081
19082   arg1 = (Dali::ConnectionTracker *)jarg1;
19083   {
19084     try {
19085       (arg1)->DisconnectAll();
19086     } catch (std::out_of_range& e) {
19087       {
19088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19089       };
19090     } catch (std::exception& e) {
19091       {
19092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19093       };
19094     } catch (Dali::DaliException e) {
19095       {
19096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19097       };
19098     } catch (...) {
19099       {
19100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19101       };
19102     }
19103   }
19104
19105 }
19106
19107
19108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19109   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19110   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19111   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19112
19113   arg1 = (Dali::ConnectionTracker *)jarg1;
19114   arg2 = (Dali::SlotObserver *)jarg2;
19115   arg3 = (Dali::CallbackBase *)jarg3;
19116   {
19117     try {
19118       (arg1)->SignalConnected(arg2,arg3);
19119     } catch (std::out_of_range& e) {
19120       {
19121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19122       };
19123     } catch (std::exception& e) {
19124       {
19125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19126       };
19127     } catch (Dali::DaliException e) {
19128       {
19129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19130       };
19131     } catch (...) {
19132       {
19133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19134       };
19135     }
19136   }
19137
19138 }
19139
19140
19141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19142   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19143   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19144   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19145
19146   arg1 = (Dali::ConnectionTracker *)jarg1;
19147   arg2 = (Dali::SlotObserver *)jarg2;
19148   arg3 = (Dali::CallbackBase *)jarg3;
19149   {
19150     try {
19151       (arg1)->SignalDisconnected(arg2,arg3);
19152     } catch (std::out_of_range& e) {
19153       {
19154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19155       };
19156     } catch (std::exception& e) {
19157       {
19158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19159       };
19160     } catch (Dali::DaliException e) {
19161       {
19162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19163       };
19164     } catch (...) {
19165       {
19166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19167       };
19168     }
19169   }
19170
19171 }
19172
19173
19174 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19175   unsigned long jresult ;
19176   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19177   std::size_t result;
19178
19179   arg1 = (Dali::ConnectionTracker *)jarg1;
19180   {
19181     try {
19182       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19183     } catch (std::out_of_range& e) {
19184       {
19185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19186       };
19187     } catch (std::exception& e) {
19188       {
19189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19190       };
19191     } catch (Dali::DaliException e) {
19192       {
19193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19194       };
19195     } catch (...) {
19196       {
19197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19198       };
19199     }
19200   }
19201
19202   jresult = (unsigned long)result;
19203   return jresult;
19204 }
19205
19206
19207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19208   void * jresult ;
19209   Dali::ObjectRegistry *result = 0 ;
19210
19211   {
19212     try {
19213       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19214     } catch (std::out_of_range& e) {
19215       {
19216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19217       };
19218     } catch (std::exception& e) {
19219       {
19220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19221       };
19222     } catch (Dali::DaliException e) {
19223       {
19224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19225       };
19226     } catch (...) {
19227       {
19228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19229       };
19230     }
19231   }
19232
19233   jresult = (void *)result;
19234   return jresult;
19235 }
19236
19237
19238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19239   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19240
19241   arg1 = (Dali::ObjectRegistry *)jarg1;
19242   {
19243     try {
19244       delete arg1;
19245     } catch (std::out_of_range& e) {
19246       {
19247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19248       };
19249     } catch (std::exception& e) {
19250       {
19251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19252       };
19253     } catch (Dali::DaliException e) {
19254       {
19255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19256       };
19257     } catch (...) {
19258       {
19259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19260       };
19261     }
19262   }
19263
19264 }
19265
19266
19267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19268   void * jresult ;
19269   Dali::ObjectRegistry *arg1 = 0 ;
19270   Dali::ObjectRegistry *result = 0 ;
19271
19272   arg1 = (Dali::ObjectRegistry *)jarg1;
19273   if (!arg1) {
19274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19275     return 0;
19276   }
19277   {
19278     try {
19279       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19280     } catch (std::out_of_range& e) {
19281       {
19282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19283       };
19284     } catch (std::exception& e) {
19285       {
19286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19287       };
19288     } catch (Dali::DaliException e) {
19289       {
19290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19291       };
19292     } catch (...) {
19293       {
19294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19295       };
19296     }
19297   }
19298
19299   jresult = (void *)result;
19300   return jresult;
19301 }
19302
19303
19304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19305   void * jresult ;
19306   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19307   Dali::ObjectRegistry *arg2 = 0 ;
19308   Dali::ObjectRegistry *result = 0 ;
19309
19310   arg1 = (Dali::ObjectRegistry *)jarg1;
19311   arg2 = (Dali::ObjectRegistry *)jarg2;
19312   if (!arg2) {
19313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19314     return 0;
19315   }
19316   {
19317     try {
19318       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19319     } catch (std::out_of_range& e) {
19320       {
19321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19322       };
19323     } catch (std::exception& e) {
19324       {
19325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19326       };
19327     } catch (Dali::DaliException e) {
19328       {
19329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19330       };
19331     } catch (...) {
19332       {
19333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19334       };
19335     }
19336   }
19337
19338   jresult = (void *)result;
19339   return jresult;
19340 }
19341
19342
19343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19344   void * jresult ;
19345   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19346   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19347
19348   arg1 = (Dali::ObjectRegistry *)jarg1;
19349   {
19350     try {
19351       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19352     } catch (std::out_of_range& e) {
19353       {
19354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19355       };
19356     } catch (std::exception& e) {
19357       {
19358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19359       };
19360     } catch (Dali::DaliException e) {
19361       {
19362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19363       };
19364     } catch (...) {
19365       {
19366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19367       };
19368     }
19369   }
19370
19371   jresult = (void *)result;
19372   return jresult;
19373 }
19374
19375
19376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19377   void * jresult ;
19378   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19379   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19380
19381   arg1 = (Dali::ObjectRegistry *)jarg1;
19382   {
19383     try {
19384       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19385     } catch (std::out_of_range& e) {
19386       {
19387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19388       };
19389     } catch (std::exception& e) {
19390       {
19391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19392       };
19393     } catch (Dali::DaliException e) {
19394       {
19395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19396       };
19397     } catch (...) {
19398       {
19399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19400       };
19401     }
19402   }
19403
19404   jresult = (void *)result;
19405   return jresult;
19406 }
19407
19408
19409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19410   void * jresult ;
19411   Dali::PropertyCondition *result = 0 ;
19412
19413   {
19414     try {
19415       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19416     } catch (std::out_of_range& e) {
19417       {
19418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19419       };
19420     } catch (std::exception& e) {
19421       {
19422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19423       };
19424     } catch (Dali::DaliException e) {
19425       {
19426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19427       };
19428     } catch (...) {
19429       {
19430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19431       };
19432     }
19433   }
19434
19435   jresult = (void *)result;
19436   return jresult;
19437 }
19438
19439
19440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19441   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19442
19443   arg1 = (Dali::PropertyCondition *)jarg1;
19444   {
19445     try {
19446       delete arg1;
19447     } catch (std::out_of_range& e) {
19448       {
19449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19450       };
19451     } catch (std::exception& e) {
19452       {
19453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19454       };
19455     } catch (Dali::DaliException e) {
19456       {
19457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19458       };
19459     } catch (...) {
19460       {
19461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19462       };
19463     }
19464   }
19465
19466 }
19467
19468
19469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19470   void * jresult ;
19471   Dali::PropertyCondition *arg1 = 0 ;
19472   Dali::PropertyCondition *result = 0 ;
19473
19474   arg1 = (Dali::PropertyCondition *)jarg1;
19475   if (!arg1) {
19476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19477     return 0;
19478   }
19479   {
19480     try {
19481       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19482     } catch (std::out_of_range& e) {
19483       {
19484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19485       };
19486     } catch (std::exception& e) {
19487       {
19488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19489       };
19490     } catch (Dali::DaliException e) {
19491       {
19492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19493       };
19494     } catch (...) {
19495       {
19496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19497       };
19498     }
19499   }
19500
19501   jresult = (void *)result;
19502   return jresult;
19503 }
19504
19505
19506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19507   void * jresult ;
19508   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19509   Dali::PropertyCondition *arg2 = 0 ;
19510   Dali::PropertyCondition *result = 0 ;
19511
19512   arg1 = (Dali::PropertyCondition *)jarg1;
19513   arg2 = (Dali::PropertyCondition *)jarg2;
19514   if (!arg2) {
19515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19516     return 0;
19517   }
19518   {
19519     try {
19520       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19521     } catch (std::out_of_range& e) {
19522       {
19523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19524       };
19525     } catch (std::exception& e) {
19526       {
19527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19528       };
19529     } catch (Dali::DaliException e) {
19530       {
19531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19532       };
19533     } catch (...) {
19534       {
19535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19536       };
19537     }
19538   }
19539
19540   jresult = (void *)result;
19541   return jresult;
19542 }
19543
19544
19545 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19546   unsigned long jresult ;
19547   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19548   std::size_t result;
19549
19550   arg1 = (Dali::PropertyCondition *)jarg1;
19551   {
19552     try {
19553       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19554     } catch (std::out_of_range& e) {
19555       {
19556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19557       };
19558     } catch (std::exception& e) {
19559       {
19560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19561       };
19562     } catch (...) {
19563       {
19564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19565       };
19566     }
19567   }
19568   jresult = (unsigned long)result;
19569   return jresult;
19570 }
19571
19572
19573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19574   float jresult ;
19575   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19576   std::size_t arg2 ;
19577   float result;
19578
19579   arg1 = (Dali::PropertyCondition *)jarg1;
19580   arg2 = (std::size_t)jarg2;
19581   {
19582     try {
19583       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19584     } catch (std::out_of_range& e) {
19585       {
19586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19587       };
19588     } catch (std::exception& e) {
19589       {
19590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19591       };
19592     } catch (...) {
19593       {
19594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19595       };
19596     }
19597   }
19598   jresult = result;
19599   return jresult;
19600 }
19601
19602
19603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19604   void * jresult ;
19605   float arg1 ;
19606   Dali::PropertyCondition result;
19607
19608   arg1 = (float)jarg1;
19609   {
19610     try {
19611       result = Dali::LessThanCondition(arg1);
19612     } catch (std::out_of_range& e) {
19613       {
19614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19615       };
19616     } catch (std::exception& e) {
19617       {
19618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19619       };
19620     } catch (Dali::DaliException e) {
19621       {
19622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19623       };
19624     } catch (...) {
19625       {
19626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19627       };
19628     }
19629   }
19630
19631   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19632   return jresult;
19633 }
19634
19635
19636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19637   void * jresult ;
19638   float arg1 ;
19639   Dali::PropertyCondition result;
19640
19641   arg1 = (float)jarg1;
19642   {
19643     try {
19644       result = Dali::GreaterThanCondition(arg1);
19645     } catch (std::out_of_range& e) {
19646       {
19647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19648       };
19649     } catch (std::exception& e) {
19650       {
19651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19652       };
19653     } catch (Dali::DaliException e) {
19654       {
19655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19656       };
19657     } catch (...) {
19658       {
19659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19660       };
19661     }
19662   }
19663
19664   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19665   return jresult;
19666 }
19667
19668
19669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19670   void * jresult ;
19671   float arg1 ;
19672   float arg2 ;
19673   Dali::PropertyCondition result;
19674
19675   arg1 = (float)jarg1;
19676   arg2 = (float)jarg2;
19677   {
19678     try {
19679       result = Dali::InsideCondition(arg1,arg2);
19680     } catch (std::out_of_range& e) {
19681       {
19682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19683       };
19684     } catch (std::exception& e) {
19685       {
19686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19687       };
19688     } catch (Dali::DaliException e) {
19689       {
19690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19691       };
19692     } catch (...) {
19693       {
19694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19695       };
19696     }
19697   }
19698
19699   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19700   return jresult;
19701 }
19702
19703
19704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19705   void * jresult ;
19706   float arg1 ;
19707   float arg2 ;
19708   Dali::PropertyCondition result;
19709
19710   arg1 = (float)jarg1;
19711   arg2 = (float)jarg2;
19712   {
19713     try {
19714       result = Dali::OutsideCondition(arg1,arg2);
19715     } catch (std::out_of_range& e) {
19716       {
19717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19718       };
19719     } catch (std::exception& e) {
19720       {
19721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19722       };
19723     } catch (Dali::DaliException e) {
19724       {
19725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19726       };
19727     } catch (...) {
19728       {
19729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19730       };
19731     }
19732   }
19733
19734   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19735   return jresult;
19736 }
19737
19738
19739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19740   void * jresult ;
19741   float arg1 ;
19742   float arg2 ;
19743   Dali::PropertyCondition result;
19744
19745   arg1 = (float)jarg1;
19746   arg2 = (float)jarg2;
19747   {
19748     try {
19749       result = Dali::StepCondition(arg1,arg2);
19750     } catch (std::out_of_range& e) {
19751       {
19752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19753       };
19754     } catch (std::exception& e) {
19755       {
19756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19757       };
19758     } catch (Dali::DaliException e) {
19759       {
19760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19761       };
19762     } catch (...) {
19763       {
19764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19765       };
19766     }
19767   }
19768
19769   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19770   return jresult;
19771 }
19772
19773
19774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19775   void * jresult ;
19776   float arg1 ;
19777   Dali::PropertyCondition result;
19778
19779   arg1 = (float)jarg1;
19780   {
19781     try {
19782       result = Dali::StepCondition(arg1);
19783     } catch (std::out_of_range& e) {
19784       {
19785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19786       };
19787     } catch (std::exception& e) {
19788       {
19789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19790       };
19791     } catch (Dali::DaliException e) {
19792       {
19793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19794       };
19795     } catch (...) {
19796       {
19797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19798       };
19799     }
19800   }
19801
19802   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19803   return jresult;
19804 }
19805
19806
19807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19808   void * jresult ;
19809   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19810   Dali::PropertyCondition result;
19811
19812   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19813   if (!arg1) {
19814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19815     return 0;
19816   }
19817   {
19818     try {
19819       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19820     } catch (std::out_of_range& e) {
19821       {
19822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19823       };
19824     } catch (std::exception& e) {
19825       {
19826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19827       };
19828     } catch (Dali::DaliException e) {
19829       {
19830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19831       };
19832     } catch (...) {
19833       {
19834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19835       };
19836     }
19837   }
19838
19839   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19840   return jresult;
19841 }
19842
19843
19844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19845   void * jresult ;
19846   Dali::PropertyNotification *result = 0 ;
19847
19848   {
19849     try {
19850       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19851     } catch (std::out_of_range& e) {
19852       {
19853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19854       };
19855     } catch (std::exception& e) {
19856       {
19857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19858       };
19859     } catch (Dali::DaliException e) {
19860       {
19861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19862       };
19863     } catch (...) {
19864       {
19865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19866       };
19867     }
19868   }
19869
19870   jresult = (void *)result;
19871   return jresult;
19872 }
19873
19874
19875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19876   void * jresult ;
19877   Dali::BaseHandle arg1 ;
19878   Dali::BaseHandle *argp1 ;
19879   Dali::PropertyNotification result;
19880
19881   argp1 = (Dali::BaseHandle *)jarg1;
19882   if (!argp1) {
19883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19884     return 0;
19885   }
19886   arg1 = *argp1;
19887   {
19888     try {
19889       result = Dali::PropertyNotification::DownCast(arg1);
19890     } catch (std::out_of_range& e) {
19891       {
19892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19893       };
19894     } catch (std::exception& e) {
19895       {
19896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19897       };
19898     } catch (Dali::DaliException e) {
19899       {
19900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19901       };
19902     } catch (...) {
19903       {
19904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19905       };
19906     }
19907   }
19908
19909   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19910   return jresult;
19911 }
19912
19913
19914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19915   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19916
19917   arg1 = (Dali::PropertyNotification *)jarg1;
19918   {
19919     try {
19920       delete arg1;
19921     } catch (std::out_of_range& e) {
19922       {
19923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19924       };
19925     } catch (std::exception& e) {
19926       {
19927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19928       };
19929     } catch (Dali::DaliException e) {
19930       {
19931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19932       };
19933     } catch (...) {
19934       {
19935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19936       };
19937     }
19938   }
19939
19940 }
19941
19942
19943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19944   void * jresult ;
19945   Dali::PropertyNotification *arg1 = 0 ;
19946   Dali::PropertyNotification *result = 0 ;
19947
19948   arg1 = (Dali::PropertyNotification *)jarg1;
19949   if (!arg1) {
19950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19951     return 0;
19952   }
19953   {
19954     try {
19955       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19956     } catch (std::out_of_range& e) {
19957       {
19958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19959       };
19960     } catch (std::exception& e) {
19961       {
19962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19963       };
19964     } catch (Dali::DaliException e) {
19965       {
19966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19967       };
19968     } catch (...) {
19969       {
19970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19971       };
19972     }
19973   }
19974
19975   jresult = (void *)result;
19976   return jresult;
19977 }
19978
19979
19980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19981   void * jresult ;
19982   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19983   Dali::PropertyNotification *arg2 = 0 ;
19984   Dali::PropertyNotification *result = 0 ;
19985
19986   arg1 = (Dali::PropertyNotification *)jarg1;
19987   arg2 = (Dali::PropertyNotification *)jarg2;
19988   if (!arg2) {
19989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19990     return 0;
19991   }
19992   {
19993     try {
19994       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19995     } catch (std::out_of_range& e) {
19996       {
19997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19998       };
19999     } catch (std::exception& e) {
20000       {
20001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20002       };
20003     } catch (Dali::DaliException e) {
20004       {
20005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20006       };
20007     } catch (...) {
20008       {
20009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20010       };
20011     }
20012   }
20013
20014   jresult = (void *)result;
20015   return jresult;
20016 }
20017
20018
20019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20020   void * jresult ;
20021   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20022   Dali::PropertyCondition result;
20023
20024   arg1 = (Dali::PropertyNotification *)jarg1;
20025   {
20026     try {
20027       result = (arg1)->GetCondition();
20028     } catch (std::out_of_range& e) {
20029       {
20030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20031       };
20032     } catch (std::exception& e) {
20033       {
20034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20035       };
20036     } catch (Dali::DaliException e) {
20037       {
20038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20039       };
20040     } catch (...) {
20041       {
20042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20043       };
20044     }
20045   }
20046
20047   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20048   return jresult;
20049 }
20050
20051
20052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20053   void * jresult ;
20054   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20055   Dali::Handle result;
20056
20057   arg1 = (Dali::PropertyNotification *)jarg1;
20058   {
20059     try {
20060       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20061     } catch (std::out_of_range& e) {
20062       {
20063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20064       };
20065     } catch (std::exception& e) {
20066       {
20067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20068       };
20069     } catch (Dali::DaliException e) {
20070       {
20071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20072       };
20073     } catch (...) {
20074       {
20075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20076       };
20077     }
20078   }
20079
20080   jresult = new Dali::Handle((const Dali::Handle &)result);
20081   return jresult;
20082 }
20083
20084
20085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20086   int jresult ;
20087   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20088   Dali::Property::Index result;
20089
20090   arg1 = (Dali::PropertyNotification *)jarg1;
20091   {
20092     try {
20093       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20094     } catch (std::out_of_range& e) {
20095       {
20096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20097       };
20098     } catch (std::exception& e) {
20099       {
20100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20101       };
20102     } catch (Dali::DaliException e) {
20103       {
20104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20105       };
20106     } catch (...) {
20107       {
20108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20109       };
20110     }
20111   }
20112
20113   jresult = result;
20114   return jresult;
20115 }
20116
20117
20118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20119   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20120   Dali::PropertyNotification::NotifyMode arg2 ;
20121
20122   arg1 = (Dali::PropertyNotification *)jarg1;
20123   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20124   {
20125     try {
20126       (arg1)->SetNotifyMode(arg2);
20127     } catch (std::out_of_range& e) {
20128       {
20129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20130       };
20131     } catch (std::exception& e) {
20132       {
20133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20134       };
20135     } catch (Dali::DaliException e) {
20136       {
20137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20138       };
20139     } catch (...) {
20140       {
20141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20142       };
20143     }
20144   }
20145
20146 }
20147
20148
20149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20150   int jresult ;
20151   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20152   Dali::PropertyNotification::NotifyMode result;
20153
20154   arg1 = (Dali::PropertyNotification *)jarg1;
20155   {
20156     try {
20157       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20158     } catch (std::out_of_range& e) {
20159       {
20160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20161       };
20162     } catch (std::exception& e) {
20163       {
20164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20165       };
20166     } catch (Dali::DaliException e) {
20167       {
20168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20169       };
20170     } catch (...) {
20171       {
20172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20173       };
20174     }
20175   }
20176
20177   jresult = (int)result;
20178   return jresult;
20179 }
20180
20181
20182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20183   unsigned int jresult ;
20184   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20185   bool result;
20186
20187   arg1 = (Dali::PropertyNotification *)jarg1;
20188   {
20189     try {
20190       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20191     } catch (std::out_of_range& e) {
20192       {
20193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20194       };
20195     } catch (std::exception& e) {
20196       {
20197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20198       };
20199     } catch (Dali::DaliException e) {
20200       {
20201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20202       };
20203     } catch (...) {
20204       {
20205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20206       };
20207     }
20208   }
20209
20210   jresult = result;
20211   return jresult;
20212 }
20213
20214
20215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20216   void * jresult ;
20217   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20218   Dali::PropertyNotifySignalType *result = 0 ;
20219
20220   arg1 = (Dali::PropertyNotification *)jarg1;
20221   {
20222     try {
20223       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20224     } catch (std::out_of_range& e) {
20225       {
20226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20227       };
20228     } catch (std::exception& e) {
20229       {
20230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20231       };
20232     } catch (Dali::DaliException e) {
20233       {
20234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20235       };
20236     } catch (...) {
20237       {
20238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20239       };
20240     }
20241   }
20242
20243   jresult = (void *)result;
20244   return jresult;
20245 }
20246
20247
20248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20249   void * jresult ;
20250   Dali::Handle *result = 0 ;
20251
20252   {
20253     try {
20254       result = (Dali::Handle *)new Dali::Handle();
20255     } catch (std::out_of_range& e) {
20256       {
20257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20258       };
20259     } catch (std::exception& e) {
20260       {
20261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20262       };
20263     } catch (Dali::DaliException e) {
20264       {
20265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20266       };
20267     } catch (...) {
20268       {
20269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20270       };
20271     }
20272   }
20273
20274   jresult = (void *)result;
20275   return jresult;
20276 }
20277
20278
20279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20280   void * jresult ;
20281   Dali::Handle result;
20282
20283   {
20284     try {
20285       result = Dali::Handle::New();
20286     } catch (std::out_of_range& e) {
20287       {
20288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20289       };
20290     } catch (std::exception& e) {
20291       {
20292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20293       };
20294     } catch (Dali::DaliException e) {
20295       {
20296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20297       };
20298     } catch (...) {
20299       {
20300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20301       };
20302     }
20303   }
20304
20305   jresult = new Dali::Handle((const Dali::Handle &)result);
20306   return jresult;
20307 }
20308
20309
20310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20311   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20312
20313   arg1 = (Dali::Handle *)jarg1;
20314   {
20315     try {
20316       delete arg1;
20317     } catch (std::out_of_range& e) {
20318       {
20319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20320       };
20321     } catch (std::exception& e) {
20322       {
20323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20324       };
20325     } catch (Dali::DaliException e) {
20326       {
20327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20328       };
20329     } catch (...) {
20330       {
20331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20332       };
20333     }
20334   }
20335
20336 }
20337
20338
20339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20340   void * jresult ;
20341   Dali::Handle *arg1 = 0 ;
20342   Dali::Handle *result = 0 ;
20343
20344   arg1 = (Dali::Handle *)jarg1;
20345   if (!arg1) {
20346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20347     return 0;
20348   }
20349   {
20350     try {
20351       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20352     } catch (std::out_of_range& e) {
20353       {
20354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20355       };
20356     } catch (std::exception& e) {
20357       {
20358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20359       };
20360     } catch (Dali::DaliException e) {
20361       {
20362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20363       };
20364     } catch (...) {
20365       {
20366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20367       };
20368     }
20369   }
20370
20371   jresult = (void *)result;
20372   return jresult;
20373 }
20374
20375
20376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20377   void * jresult ;
20378   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20379   Dali::Handle *arg2 = 0 ;
20380   Dali::Handle *result = 0 ;
20381
20382   arg1 = (Dali::Handle *)jarg1;
20383   arg2 = (Dali::Handle *)jarg2;
20384   if (!arg2) {
20385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20386     return 0;
20387   }
20388   {
20389     try {
20390       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20391     } catch (std::out_of_range& e) {
20392       {
20393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20394       };
20395     } catch (std::exception& e) {
20396       {
20397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20398       };
20399     } catch (Dali::DaliException e) {
20400       {
20401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20402       };
20403     } catch (...) {
20404       {
20405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20406       };
20407     }
20408   }
20409
20410   jresult = (void *)result;
20411   return jresult;
20412 }
20413
20414
20415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20416   void * jresult ;
20417   Dali::BaseHandle arg1 ;
20418   Dali::BaseHandle *argp1 ;
20419   Dali::Handle result;
20420
20421   argp1 = (Dali::BaseHandle *)jarg1;
20422   if (!argp1) {
20423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20424     return 0;
20425   }
20426   arg1 = *argp1;
20427   {
20428     try {
20429       result = Dali::Handle::DownCast(arg1);
20430     } catch (std::out_of_range& e) {
20431       {
20432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20433       };
20434     } catch (std::exception& e) {
20435       {
20436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20437       };
20438     } catch (Dali::DaliException e) {
20439       {
20440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20441       };
20442     } catch (...) {
20443       {
20444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20445       };
20446     }
20447   }
20448
20449   jresult = new Dali::Handle((const Dali::Handle &)result);
20450   return jresult;
20451 }
20452
20453
20454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20455   unsigned int jresult ;
20456   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20457   Dali::Handle::Capability arg2 ;
20458   bool result;
20459
20460   arg1 = (Dali::Handle *)jarg1;
20461   arg2 = (Dali::Handle::Capability)jarg2;
20462   {
20463     try {
20464       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20465     } catch (std::out_of_range& e) {
20466       {
20467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20468       };
20469     } catch (std::exception& e) {
20470       {
20471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20472       };
20473     } catch (Dali::DaliException e) {
20474       {
20475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20476       };
20477     } catch (...) {
20478       {
20479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20480       };
20481     }
20482   }
20483
20484   jresult = result;
20485   return jresult;
20486 }
20487
20488
20489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20490   unsigned int jresult ;
20491   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20492   unsigned int result;
20493
20494   arg1 = (Dali::Handle *)jarg1;
20495   {
20496     try {
20497       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20498     } catch (std::out_of_range& e) {
20499       {
20500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20501       };
20502     } catch (std::exception& e) {
20503       {
20504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20505       };
20506     } catch (Dali::DaliException e) {
20507       {
20508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20509       };
20510     } catch (...) {
20511       {
20512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20513       };
20514     }
20515   }
20516
20517   jresult = result;
20518   return jresult;
20519 }
20520
20521
20522 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20523   char * jresult ;
20524   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20525   Dali::Property::Index arg2 ;
20526   std::string result;
20527
20528   arg1 = (Dali::Handle *)jarg1;
20529   arg2 = (Dali::Property::Index)jarg2;
20530   {
20531     try {
20532       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20533     } catch (std::out_of_range& e) {
20534       {
20535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20536       };
20537     } catch (std::exception& e) {
20538       {
20539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20540       };
20541     } catch (Dali::DaliException e) {
20542       {
20543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20544       };
20545     } catch (...) {
20546       {
20547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20548       };
20549     }
20550   }
20551
20552   jresult = SWIG_csharp_string_callback((&result)->c_str());
20553   return jresult;
20554 }
20555
20556
20557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20558   int jresult ;
20559   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20560   std::string *arg2 = 0 ;
20561   Dali::Property::Index result;
20562
20563   arg1 = (Dali::Handle *)jarg1;
20564   if (!jarg2) {
20565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20566     return 0;
20567   }
20568   std::string arg2_str(jarg2);
20569   arg2 = &arg2_str;
20570   {
20571     try {
20572       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20573     } catch (std::out_of_range& e) {
20574       {
20575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20576       };
20577     } catch (std::exception& e) {
20578       {
20579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20580       };
20581     } catch (Dali::DaliException e) {
20582       {
20583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20584       };
20585     } catch (...) {
20586       {
20587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20588       };
20589     }
20590   }
20591
20592   jresult = result;
20593
20594   //argout typemap for const std::string&
20595
20596   return jresult;
20597 }
20598
20599
20600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20601   unsigned int jresult ;
20602   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20603   Dali::Property::Index arg2 ;
20604   bool result;
20605
20606   arg1 = (Dali::Handle *)jarg1;
20607   arg2 = (Dali::Property::Index)jarg2;
20608   {
20609     try {
20610       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20611     } catch (std::out_of_range& e) {
20612       {
20613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20614       };
20615     } catch (std::exception& e) {
20616       {
20617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20618       };
20619     } catch (Dali::DaliException e) {
20620       {
20621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20622       };
20623     } catch (...) {
20624       {
20625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20626       };
20627     }
20628   }
20629
20630   jresult = result;
20631   return jresult;
20632 }
20633
20634
20635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20636   unsigned int jresult ;
20637   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20638   Dali::Property::Index arg2 ;
20639   bool result;
20640
20641   arg1 = (Dali::Handle *)jarg1;
20642   arg2 = (Dali::Property::Index)jarg2;
20643   {
20644     try {
20645       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20646     } catch (std::out_of_range& e) {
20647       {
20648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20649       };
20650     } catch (std::exception& e) {
20651       {
20652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20653       };
20654     } catch (Dali::DaliException e) {
20655       {
20656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20657       };
20658     } catch (...) {
20659       {
20660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20661       };
20662     }
20663   }
20664
20665   jresult = result;
20666   return jresult;
20667 }
20668
20669
20670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20671   unsigned int jresult ;
20672   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20673   Dali::Property::Index arg2 ;
20674   bool result;
20675
20676   arg1 = (Dali::Handle *)jarg1;
20677   arg2 = (Dali::Property::Index)jarg2;
20678   {
20679     try {
20680       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20681     } catch (std::out_of_range& e) {
20682       {
20683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20684       };
20685     } catch (std::exception& e) {
20686       {
20687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20688       };
20689     } catch (Dali::DaliException e) {
20690       {
20691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20692       };
20693     } catch (...) {
20694       {
20695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20696       };
20697     }
20698   }
20699
20700   jresult = result;
20701   return jresult;
20702 }
20703
20704
20705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20706   int jresult ;
20707   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20708   Dali::Property::Index arg2 ;
20709   Dali::Property::Type result;
20710
20711   arg1 = (Dali::Handle *)jarg1;
20712   arg2 = (Dali::Property::Index)jarg2;
20713   {
20714     try {
20715       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20716     } catch (std::out_of_range& e) {
20717       {
20718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20719       };
20720     } catch (std::exception& e) {
20721       {
20722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20723       };
20724     } catch (Dali::DaliException e) {
20725       {
20726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20727       };
20728     } catch (...) {
20729       {
20730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20731       };
20732     }
20733   }
20734
20735   jresult = (int)result;
20736   return jresult;
20737 }
20738
20739
20740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20741   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20742   Dali::Property::Index arg2 ;
20743   Dali::Property::Value *arg3 = 0 ;
20744
20745   arg1 = (Dali::Handle *)jarg1;
20746   arg2 = (Dali::Property::Index)jarg2;
20747   arg3 = (Dali::Property::Value *)jarg3;
20748   if (!arg3) {
20749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20750     return ;
20751   }
20752   {
20753     try {
20754       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20755     } catch (std::out_of_range& e) {
20756       {
20757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20758       };
20759     } catch (std::exception& e) {
20760       {
20761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20762       };
20763     } catch (Dali::DaliException e) {
20764       {
20765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20766       };
20767     } catch (...) {
20768       {
20769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20770       };
20771     }
20772   }
20773
20774 }
20775
20776
20777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20778   int jresult ;
20779   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20780   std::string *arg2 = 0 ;
20781   Dali::Property::Value *arg3 = 0 ;
20782   Dali::Property::Index result;
20783
20784   arg1 = (Dali::Handle *)jarg1;
20785   if (!jarg2) {
20786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20787     return 0;
20788   }
20789   std::string arg2_str(jarg2);
20790   arg2 = &arg2_str;
20791   arg3 = (Dali::Property::Value *)jarg3;
20792   if (!arg3) {
20793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20794     return 0;
20795   }
20796   {
20797     try {
20798       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20799     } catch (std::out_of_range& e) {
20800       {
20801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20802       };
20803     } catch (std::exception& e) {
20804       {
20805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20806       };
20807     } catch (Dali::DaliException e) {
20808       {
20809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20810       };
20811     } catch (...) {
20812       {
20813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20814       };
20815     }
20816   }
20817
20818   jresult = result;
20819
20820   //argout typemap for const std::string&
20821
20822   return jresult;
20823 }
20824
20825
20826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20827   int jresult ;
20828   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20829   std::string *arg2 = 0 ;
20830   Dali::Property::Value *arg3 = 0 ;
20831   Dali::Property::AccessMode arg4 ;
20832   Dali::Property::Index result;
20833
20834   arg1 = (Dali::Handle *)jarg1;
20835   if (!jarg2) {
20836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20837     return 0;
20838   }
20839   std::string arg2_str(jarg2);
20840   arg2 = &arg2_str;
20841   arg3 = (Dali::Property::Value *)jarg3;
20842   if (!arg3) {
20843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20844     return 0;
20845   }
20846   arg4 = (Dali::Property::AccessMode)jarg4;
20847   {
20848     try {
20849       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20850     } catch (std::out_of_range& e) {
20851       {
20852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20853       };
20854     } catch (std::exception& e) {
20855       {
20856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20857       };
20858     } catch (Dali::DaliException e) {
20859       {
20860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20861       };
20862     } catch (...) {
20863       {
20864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20865       };
20866     }
20867   }
20868
20869   jresult = result;
20870
20871   //argout typemap for const std::string&
20872
20873   return jresult;
20874 }
20875
20876
20877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20878   void * jresult ;
20879   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20880   Dali::Property::Index arg2 ;
20881   Dali::Property::Value result;
20882
20883   arg1 = (Dali::Handle *)jarg1;
20884   arg2 = (Dali::Property::Index)jarg2;
20885   {
20886     try {
20887       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20888     } catch (std::out_of_range& e) {
20889       {
20890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20891       };
20892     } catch (std::exception& e) {
20893       {
20894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20895       };
20896     } catch (Dali::DaliException e) {
20897       {
20898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20899       };
20900     } catch (...) {
20901       {
20902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20903       };
20904     }
20905   }
20906
20907   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20908   return jresult;
20909 }
20910
20911
20912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20913   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20914   Dali::Property::IndexContainer *arg2 = 0 ;
20915
20916   arg1 = (Dali::Handle *)jarg1;
20917   arg2 = (Dali::Property::IndexContainer *)jarg2;
20918   if (!arg2) {
20919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20920     return ;
20921   }
20922   {
20923     try {
20924       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20925     } catch (std::out_of_range& e) {
20926       {
20927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20928       };
20929     } catch (std::exception& e) {
20930       {
20931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20932       };
20933     } catch (Dali::DaliException e) {
20934       {
20935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20936       };
20937     } catch (...) {
20938       {
20939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20940       };
20941     }
20942   }
20943
20944 }
20945
20946
20947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20948   void * jresult ;
20949   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20950   Dali::Property::Index arg2 ;
20951   Dali::PropertyCondition *arg3 = 0 ;
20952   Dali::PropertyNotification result;
20953
20954   arg1 = (Dali::Handle *)jarg1;
20955   arg2 = (Dali::Property::Index)jarg2;
20956   arg3 = (Dali::PropertyCondition *)jarg3;
20957   if (!arg3) {
20958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20959     return 0;
20960   }
20961   {
20962     try {
20963       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20964     } catch (std::out_of_range& e) {
20965       {
20966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20967       };
20968     } catch (std::exception& e) {
20969       {
20970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20971       };
20972     } catch (Dali::DaliException e) {
20973       {
20974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20975       };
20976     } catch (...) {
20977       {
20978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20979       };
20980     }
20981   }
20982
20983   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20984   return jresult;
20985 }
20986
20987
20988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20989   void * jresult ;
20990   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20991   Dali::Property::Index arg2 ;
20992   int arg3 ;
20993   Dali::PropertyCondition *arg4 = 0 ;
20994   Dali::PropertyNotification result;
20995
20996   arg1 = (Dali::Handle *)jarg1;
20997   arg2 = (Dali::Property::Index)jarg2;
20998   arg3 = (int)jarg3;
20999   arg4 = (Dali::PropertyCondition *)jarg4;
21000   if (!arg4) {
21001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21002     return 0;
21003   }
21004   {
21005     try {
21006       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21007     } catch (std::out_of_range& e) {
21008       {
21009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21010       };
21011     } catch (std::exception& e) {
21012       {
21013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21014       };
21015     } catch (Dali::DaliException e) {
21016       {
21017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21018       };
21019     } catch (...) {
21020       {
21021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21022       };
21023     }
21024   }
21025
21026   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21027   return jresult;
21028 }
21029
21030
21031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21032   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21033   Dali::PropertyNotification arg2 ;
21034   Dali::PropertyNotification *argp2 ;
21035
21036   arg1 = (Dali::Handle *)jarg1;
21037   argp2 = (Dali::PropertyNotification *)jarg2;
21038   if (!argp2) {
21039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21040     return ;
21041   }
21042   arg2 = *argp2;
21043   {
21044     try {
21045       (arg1)->RemovePropertyNotification(arg2);
21046     } catch (std::out_of_range& e) {
21047       {
21048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21049       };
21050     } catch (std::exception& e) {
21051       {
21052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21053       };
21054     } catch (Dali::DaliException e) {
21055       {
21056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21057       };
21058     } catch (...) {
21059       {
21060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21061       };
21062     }
21063   }
21064
21065 }
21066
21067
21068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21069   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21070
21071   arg1 = (Dali::Handle *)jarg1;
21072   {
21073     try {
21074       (arg1)->RemovePropertyNotifications();
21075     } catch (std::out_of_range& e) {
21076       {
21077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21078       };
21079     } catch (std::exception& e) {
21080       {
21081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21082       };
21083     } catch (Dali::DaliException e) {
21084       {
21085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21086       };
21087     } catch (...) {
21088       {
21089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21090       };
21091     }
21092   }
21093
21094 }
21095
21096
21097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21098   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21099
21100   arg1 = (Dali::Handle *)jarg1;
21101   {
21102     try {
21103       (arg1)->RemoveConstraints();
21104     } catch (std::out_of_range& e) {
21105       {
21106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21107       };
21108     } catch (std::exception& e) {
21109       {
21110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21111       };
21112     } catch (Dali::DaliException e) {
21113       {
21114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21115       };
21116     } catch (...) {
21117       {
21118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21119       };
21120     }
21121   }
21122
21123 }
21124
21125
21126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21127   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21128   unsigned int arg2 ;
21129
21130   arg1 = (Dali::Handle *)jarg1;
21131   arg2 = (unsigned int)jarg2;
21132   {
21133     try {
21134       (arg1)->RemoveConstraints(arg2);
21135     } catch (std::out_of_range& e) {
21136       {
21137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21138       };
21139     } catch (std::exception& e) {
21140       {
21141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21142       };
21143     } catch (Dali::DaliException e) {
21144       {
21145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21146       };
21147     } catch (...) {
21148       {
21149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21150       };
21151     }
21152   }
21153
21154 }
21155
21156
21157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21158   int jresult ;
21159   Dali::Property::Index result;
21160
21161   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21162   jresult = result;
21163   return jresult;
21164 }
21165
21166
21167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21168   void * jresult ;
21169   Dali::Handle result;
21170
21171   {
21172     try {
21173       result = Dali::WeightObject::New();
21174     } catch (std::out_of_range& e) {
21175       {
21176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21177       };
21178     } catch (std::exception& e) {
21179       {
21180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21181       };
21182     } catch (Dali::DaliException e) {
21183       {
21184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21185       };
21186     } catch (...) {
21187       {
21188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21189       };
21190     }
21191   }
21192
21193   jresult = new Dali::Handle((const Dali::Handle &)result);
21194   return jresult;
21195 }
21196
21197
21198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21199   void * jresult ;
21200   Dali::TypeInfo *result = 0 ;
21201
21202   {
21203     try {
21204       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21205     } catch (std::out_of_range& e) {
21206       {
21207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21208       };
21209     } catch (std::exception& e) {
21210       {
21211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21212       };
21213     } catch (Dali::DaliException e) {
21214       {
21215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21216       };
21217     } catch (...) {
21218       {
21219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21220       };
21221     }
21222   }
21223
21224   jresult = (void *)result;
21225   return jresult;
21226 }
21227
21228
21229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21230   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21231
21232   arg1 = (Dali::TypeInfo *)jarg1;
21233   {
21234     try {
21235       delete arg1;
21236     } catch (std::out_of_range& e) {
21237       {
21238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21239       };
21240     } catch (std::exception& e) {
21241       {
21242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21243       };
21244     } catch (Dali::DaliException e) {
21245       {
21246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21247       };
21248     } catch (...) {
21249       {
21250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21251       };
21252     }
21253   }
21254
21255 }
21256
21257
21258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21259   void * jresult ;
21260   Dali::TypeInfo *arg1 = 0 ;
21261   Dali::TypeInfo *result = 0 ;
21262
21263   arg1 = (Dali::TypeInfo *)jarg1;
21264   if (!arg1) {
21265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21266     return 0;
21267   }
21268   {
21269     try {
21270       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21271     } catch (std::out_of_range& e) {
21272       {
21273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21274       };
21275     } catch (std::exception& e) {
21276       {
21277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21278       };
21279     } catch (Dali::DaliException e) {
21280       {
21281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21282       };
21283     } catch (...) {
21284       {
21285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21286       };
21287     }
21288   }
21289
21290   jresult = (void *)result;
21291   return jresult;
21292 }
21293
21294
21295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21296   void * jresult ;
21297   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21298   Dali::TypeInfo *arg2 = 0 ;
21299   Dali::TypeInfo *result = 0 ;
21300
21301   arg1 = (Dali::TypeInfo *)jarg1;
21302   arg2 = (Dali::TypeInfo *)jarg2;
21303   if (!arg2) {
21304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21305     return 0;
21306   }
21307   {
21308     try {
21309       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21310     } catch (std::out_of_range& e) {
21311       {
21312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21313       };
21314     } catch (std::exception& e) {
21315       {
21316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21317       };
21318     } catch (Dali::DaliException e) {
21319       {
21320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21321       };
21322     } catch (...) {
21323       {
21324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21325       };
21326     }
21327   }
21328
21329   jresult = (void *)result;
21330   return jresult;
21331 }
21332
21333
21334 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21335   char * jresult ;
21336   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21337   std::string *result = 0 ;
21338
21339   arg1 = (Dali::TypeInfo *)jarg1;
21340   {
21341     try {
21342       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21343     } catch (std::out_of_range& e) {
21344       {
21345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21346       };
21347     } catch (std::exception& e) {
21348       {
21349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21350       };
21351     } catch (Dali::DaliException e) {
21352       {
21353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21354       };
21355     } catch (...) {
21356       {
21357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21358       };
21359     }
21360   }
21361
21362   jresult = SWIG_csharp_string_callback(result->c_str());
21363   return jresult;
21364 }
21365
21366
21367 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21368   char * jresult ;
21369   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21370   std::string *result = 0 ;
21371
21372   arg1 = (Dali::TypeInfo *)jarg1;
21373   {
21374     try {
21375       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21376     } catch (std::out_of_range& e) {
21377       {
21378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21379       };
21380     } catch (std::exception& e) {
21381       {
21382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21383       };
21384     } catch (Dali::DaliException e) {
21385       {
21386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21387       };
21388     } catch (...) {
21389       {
21390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21391       };
21392     }
21393   }
21394
21395   jresult = SWIG_csharp_string_callback(result->c_str());
21396   return jresult;
21397 }
21398
21399
21400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21401   void * jresult ;
21402   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21403   Dali::BaseHandle result;
21404
21405   arg1 = (Dali::TypeInfo *)jarg1;
21406   {
21407     try {
21408       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21409     } catch (std::out_of_range& e) {
21410       {
21411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21412       };
21413     } catch (std::exception& e) {
21414       {
21415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21416       };
21417     } catch (Dali::DaliException e) {
21418       {
21419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21420       };
21421     } catch (...) {
21422       {
21423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21424       };
21425     }
21426   }
21427
21428   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21429   return jresult;
21430 }
21431
21432
21433 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21434   unsigned long jresult ;
21435   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21436   size_t result;
21437
21438   arg1 = (Dali::TypeInfo *)jarg1;
21439   {
21440     try {
21441       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21442     } catch (std::out_of_range& e) {
21443       {
21444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21445       };
21446     } catch (std::exception& e) {
21447       {
21448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21449       };
21450     } catch (Dali::DaliException e) {
21451       {
21452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21453       };
21454     } catch (...) {
21455       {
21456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21457       };
21458     }
21459   }
21460
21461   jresult = (unsigned long)result;
21462   return jresult;
21463 }
21464
21465
21466 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21467   char * jresult ;
21468   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21469   size_t arg2 ;
21470   std::string result;
21471
21472   arg1 = (Dali::TypeInfo *)jarg1;
21473   arg2 = (size_t)jarg2;
21474   {
21475     try {
21476       result = (arg1)->GetActionName(arg2);
21477     } catch (std::out_of_range& e) {
21478       {
21479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21480       };
21481     } catch (std::exception& e) {
21482       {
21483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21484       };
21485     } catch (Dali::DaliException e) {
21486       {
21487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21488       };
21489     } catch (...) {
21490       {
21491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21492       };
21493     }
21494   }
21495
21496   jresult = SWIG_csharp_string_callback((&result)->c_str());
21497   return jresult;
21498 }
21499
21500
21501 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21502   unsigned long jresult ;
21503   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21504   size_t result;
21505
21506   arg1 = (Dali::TypeInfo *)jarg1;
21507   {
21508     try {
21509       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21510     } catch (std::out_of_range& e) {
21511       {
21512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21513       };
21514     } catch (std::exception& e) {
21515       {
21516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21517       };
21518     } catch (Dali::DaliException e) {
21519       {
21520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21521       };
21522     } catch (...) {
21523       {
21524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21525       };
21526     }
21527   }
21528
21529   jresult = (unsigned long)result;
21530   return jresult;
21531 }
21532
21533
21534 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21535   char * jresult ;
21536   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21537   size_t arg2 ;
21538   std::string result;
21539
21540   arg1 = (Dali::TypeInfo *)jarg1;
21541   arg2 = (size_t)jarg2;
21542   {
21543     try {
21544       result = (arg1)->GetSignalName(arg2);
21545     } catch (std::out_of_range& e) {
21546       {
21547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21548       };
21549     } catch (std::exception& e) {
21550       {
21551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21552       };
21553     } catch (Dali::DaliException e) {
21554       {
21555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21556       };
21557     } catch (...) {
21558       {
21559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21560       };
21561     }
21562   }
21563
21564   jresult = SWIG_csharp_string_callback((&result)->c_str());
21565   return jresult;
21566 }
21567
21568
21569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21570   unsigned long jresult ;
21571   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21572   size_t result;
21573
21574   arg1 = (Dali::TypeInfo *)jarg1;
21575   {
21576     try {
21577       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21578     } catch (std::out_of_range& e) {
21579       {
21580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21581       };
21582     } catch (std::exception& e) {
21583       {
21584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21585       };
21586     } catch (Dali::DaliException e) {
21587       {
21588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21589       };
21590     } catch (...) {
21591       {
21592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21593       };
21594     }
21595   }
21596
21597   jresult = (unsigned long)result;
21598   return jresult;
21599 }
21600
21601
21602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21603   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21604   Dali::Property::IndexContainer *arg2 = 0 ;
21605
21606   arg1 = (Dali::TypeInfo *)jarg1;
21607   arg2 = (Dali::Property::IndexContainer *)jarg2;
21608   if (!arg2) {
21609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21610     return ;
21611   }
21612   {
21613     try {
21614       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21615     } catch (std::out_of_range& e) {
21616       {
21617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21618       };
21619     } catch (std::exception& e) {
21620       {
21621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21622       };
21623     } catch (Dali::DaliException e) {
21624       {
21625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21626       };
21627     } catch (...) {
21628       {
21629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21630       };
21631     }
21632   }
21633
21634 }
21635
21636
21637 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21638   char * jresult ;
21639   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21640   Dali::Property::Index arg2 ;
21641   std::string *result = 0 ;
21642
21643   arg1 = (Dali::TypeInfo *)jarg1;
21644   arg2 = (Dali::Property::Index)jarg2;
21645   {
21646     try {
21647       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21648     } catch (std::out_of_range& e) {
21649       {
21650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21651       };
21652     } catch (std::exception& e) {
21653       {
21654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21655       };
21656     } catch (Dali::DaliException e) {
21657       {
21658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21659       };
21660     } catch (...) {
21661       {
21662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21663       };
21664     }
21665   }
21666
21667   jresult = SWIG_csharp_string_callback(result->c_str());
21668   return jresult;
21669 }
21670
21671
21672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21673   void * jresult ;
21674   Dali::TypeRegistry result;
21675
21676   {
21677     try {
21678       result = Dali::TypeRegistry::Get();
21679     } catch (std::out_of_range& e) {
21680       {
21681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21682       };
21683     } catch (std::exception& e) {
21684       {
21685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21686       };
21687     } catch (Dali::DaliException e) {
21688       {
21689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21690       };
21691     } catch (...) {
21692       {
21693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21694       };
21695     }
21696   }
21697
21698   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21699   return jresult;
21700 }
21701
21702
21703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21704   void * jresult ;
21705   Dali::TypeRegistry *result = 0 ;
21706
21707   {
21708     try {
21709       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21710     } catch (std::out_of_range& e) {
21711       {
21712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21713       };
21714     } catch (std::exception& e) {
21715       {
21716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21717       };
21718     } catch (Dali::DaliException e) {
21719       {
21720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21721       };
21722     } catch (...) {
21723       {
21724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21725       };
21726     }
21727   }
21728
21729   jresult = (void *)result;
21730   return jresult;
21731 }
21732
21733
21734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21735   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21736
21737   arg1 = (Dali::TypeRegistry *)jarg1;
21738   {
21739     try {
21740       delete arg1;
21741     } catch (std::out_of_range& e) {
21742       {
21743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21744       };
21745     } catch (std::exception& e) {
21746       {
21747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21748       };
21749     } catch (Dali::DaliException e) {
21750       {
21751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21752       };
21753     } catch (...) {
21754       {
21755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21756       };
21757     }
21758   }
21759
21760 }
21761
21762
21763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21764   void * jresult ;
21765   Dali::TypeRegistry *arg1 = 0 ;
21766   Dali::TypeRegistry *result = 0 ;
21767
21768   arg1 = (Dali::TypeRegistry *)jarg1;
21769   if (!arg1) {
21770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21771     return 0;
21772   }
21773   {
21774     try {
21775       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21776     } catch (std::out_of_range& e) {
21777       {
21778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21779       };
21780     } catch (std::exception& e) {
21781       {
21782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21783       };
21784     } catch (Dali::DaliException e) {
21785       {
21786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21787       };
21788     } catch (...) {
21789       {
21790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21791       };
21792     }
21793   }
21794
21795   jresult = (void *)result;
21796   return jresult;
21797 }
21798
21799
21800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21801   void * jresult ;
21802   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21803   Dali::TypeRegistry *arg2 = 0 ;
21804   Dali::TypeRegistry *result = 0 ;
21805
21806   arg1 = (Dali::TypeRegistry *)jarg1;
21807   arg2 = (Dali::TypeRegistry *)jarg2;
21808   if (!arg2) {
21809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21810     return 0;
21811   }
21812   {
21813     try {
21814       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21815     } catch (std::out_of_range& e) {
21816       {
21817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21818       };
21819     } catch (std::exception& e) {
21820       {
21821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21822       };
21823     } catch (Dali::DaliException e) {
21824       {
21825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21826       };
21827     } catch (...) {
21828       {
21829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21830       };
21831     }
21832   }
21833
21834   jresult = (void *)result;
21835   return jresult;
21836 }
21837
21838
21839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21840   void * jresult ;
21841   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21842   std::string *arg2 = 0 ;
21843   Dali::TypeInfo result;
21844
21845   arg1 = (Dali::TypeRegistry *)jarg1;
21846   if (!jarg2) {
21847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21848     return 0;
21849   }
21850   std::string arg2_str(jarg2);
21851   arg2 = &arg2_str;
21852   {
21853     try {
21854       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21855     } catch (std::out_of_range& e) {
21856       {
21857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21858       };
21859     } catch (std::exception& e) {
21860       {
21861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21862       };
21863     } catch (Dali::DaliException e) {
21864       {
21865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21866       };
21867     } catch (...) {
21868       {
21869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21870       };
21871     }
21872   }
21873
21874   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21875
21876   //argout typemap for const std::string&
21877
21878   return jresult;
21879 }
21880
21881
21882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21883   void * jresult ;
21884   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21885   std::type_info *arg2 = 0 ;
21886   Dali::TypeInfo result;
21887
21888   arg1 = (Dali::TypeRegistry *)jarg1;
21889   arg2 = (std::type_info *)jarg2;
21890   if (!arg2) {
21891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21892     return 0;
21893   }
21894   {
21895     try {
21896       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21897     } catch (std::out_of_range& e) {
21898       {
21899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21900       };
21901     } catch (std::exception& e) {
21902       {
21903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21904       };
21905     } catch (Dali::DaliException e) {
21906       {
21907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21908       };
21909     } catch (...) {
21910       {
21911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21912       };
21913     }
21914   }
21915
21916   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21917   return jresult;
21918 }
21919
21920
21921 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21922   unsigned long jresult ;
21923   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21924   size_t result;
21925
21926   arg1 = (Dali::TypeRegistry *)jarg1;
21927   {
21928     try {
21929       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21930     } catch (std::out_of_range& e) {
21931       {
21932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21933       };
21934     } catch (std::exception& e) {
21935       {
21936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21937       };
21938     } catch (Dali::DaliException e) {
21939       {
21940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21941       };
21942     } catch (...) {
21943       {
21944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21945       };
21946     }
21947   }
21948
21949   jresult = (unsigned long)result;
21950   return jresult;
21951 }
21952
21953
21954 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21955   char * jresult ;
21956   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21957   size_t arg2 ;
21958   std::string result;
21959
21960   arg1 = (Dali::TypeRegistry *)jarg1;
21961   arg2 = (size_t)jarg2;
21962   {
21963     try {
21964       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21965     } catch (std::out_of_range& e) {
21966       {
21967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21968       };
21969     } catch (std::exception& e) {
21970       {
21971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21972       };
21973     } catch (Dali::DaliException e) {
21974       {
21975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21976       };
21977     } catch (...) {
21978       {
21979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21980       };
21981     }
21982   }
21983
21984   jresult = SWIG_csharp_string_callback((&result)->c_str());
21985   return jresult;
21986 }
21987
21988
21989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21990   void * jresult ;
21991   std::type_info *arg1 = 0 ;
21992   std::type_info *arg2 = 0 ;
21993   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21994   Dali::TypeRegistration *result = 0 ;
21995
21996   arg1 = (std::type_info *)jarg1;
21997   if (!arg1) {
21998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21999     return 0;
22000   }
22001   arg2 = (std::type_info *)jarg2;
22002   if (!arg2) {
22003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22004     return 0;
22005   }
22006   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22007   {
22008     try {
22009       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22010     } catch (std::out_of_range& e) {
22011       {
22012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22013       };
22014     } catch (std::exception& e) {
22015       {
22016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22017       };
22018     } catch (Dali::DaliException e) {
22019       {
22020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22021       };
22022     } catch (...) {
22023       {
22024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22025       };
22026     }
22027   }
22028
22029   jresult = (void *)result;
22030   return jresult;
22031 }
22032
22033
22034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22035   void * jresult ;
22036   std::type_info *arg1 = 0 ;
22037   std::type_info *arg2 = 0 ;
22038   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22039   bool arg4 ;
22040   Dali::TypeRegistration *result = 0 ;
22041
22042   arg1 = (std::type_info *)jarg1;
22043   if (!arg1) {
22044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22045     return 0;
22046   }
22047   arg2 = (std::type_info *)jarg2;
22048   if (!arg2) {
22049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22050     return 0;
22051   }
22052   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22053   arg4 = jarg4 ? true : false;
22054   {
22055     try {
22056       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22057     } catch (std::out_of_range& e) {
22058       {
22059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22060       };
22061     } catch (std::exception& e) {
22062       {
22063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22064       };
22065     } catch (Dali::DaliException e) {
22066       {
22067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22068       };
22069     } catch (...) {
22070       {
22071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22072       };
22073     }
22074   }
22075
22076   jresult = (void *)result;
22077   return jresult;
22078 }
22079
22080
22081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22082   void * jresult ;
22083   std::string *arg1 = 0 ;
22084   std::type_info *arg2 = 0 ;
22085   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22086   Dali::TypeRegistration *result = 0 ;
22087
22088   if (!jarg1) {
22089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22090     return 0;
22091   }
22092   std::string arg1_str(jarg1);
22093   arg1 = &arg1_str;
22094   arg2 = (std::type_info *)jarg2;
22095   if (!arg2) {
22096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22097     return 0;
22098   }
22099   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22100   {
22101     try {
22102       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22103     } catch (std::out_of_range& e) {
22104       {
22105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22106       };
22107     } catch (std::exception& e) {
22108       {
22109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22110       };
22111     } catch (Dali::DaliException e) {
22112       {
22113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22114       };
22115     } catch (...) {
22116       {
22117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22118       };
22119     }
22120   }
22121
22122   jresult = (void *)result;
22123
22124   //argout typemap for const std::string&
22125
22126   return jresult;
22127 }
22128
22129
22130 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22131   char * jresult ;
22132   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22133   std::string result;
22134
22135   arg1 = (Dali::TypeRegistration *)jarg1;
22136   {
22137     try {
22138       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22139     } catch (std::out_of_range& e) {
22140       {
22141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22142       };
22143     } catch (std::exception& e) {
22144       {
22145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22146       };
22147     } catch (Dali::DaliException e) {
22148       {
22149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22150       };
22151     } catch (...) {
22152       {
22153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22154       };
22155     }
22156   }
22157
22158   jresult = SWIG_csharp_string_callback((&result)->c_str());
22159   return jresult;
22160 }
22161
22162
22163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22164   std::string *arg1 = 0 ;
22165   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22166
22167   if (!jarg1) {
22168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22169     return ;
22170   }
22171   std::string arg1_str(jarg1);
22172   arg1 = &arg1_str;
22173   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22174   {
22175     try {
22176       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22177     } catch (std::out_of_range& e) {
22178       {
22179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22180       };
22181     } catch (std::exception& e) {
22182       {
22183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22184       };
22185     } catch (Dali::DaliException e) {
22186       {
22187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22188       };
22189     } catch (...) {
22190       {
22191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22192       };
22193     }
22194   }
22195
22196
22197   //argout typemap for const std::string&
22198
22199 }
22200
22201
22202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22203   std::string *arg1 = 0 ;
22204   std::string *arg2 = 0 ;
22205   int arg3 ;
22206   Dali::Property::Type arg4 ;
22207   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22208   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22209
22210   if (!jarg1) {
22211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22212     return ;
22213   }
22214   std::string arg1_str(jarg1);
22215   arg1 = &arg1_str;
22216   if (!jarg2) {
22217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22218     return ;
22219   }
22220   std::string arg2_str(jarg2);
22221   arg2 = &arg2_str;
22222   arg3 = (int)jarg3;
22223   arg4 = (Dali::Property::Type)jarg4;
22224   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22225   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22226   {
22227     try {
22228       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22229     } catch (std::out_of_range& e) {
22230       {
22231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22232       };
22233     } catch (std::exception& e) {
22234       {
22235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22236       };
22237     } catch (Dali::DaliException e) {
22238       {
22239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22240       };
22241     } catch (...) {
22242       {
22243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22244       };
22245     }
22246   }
22247
22248
22249   //argout typemap for const std::string&
22250
22251
22252   //argout typemap for const std::string&
22253
22254 }
22255
22256
22257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22258   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22259
22260   arg1 = (Dali::TypeRegistration *)jarg1;
22261   {
22262     try {
22263       delete arg1;
22264     } catch (std::out_of_range& e) {
22265       {
22266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22267       };
22268     } catch (std::exception& e) {
22269       {
22270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22271       };
22272     } catch (Dali::DaliException e) {
22273       {
22274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22275       };
22276     } catch (...) {
22277       {
22278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22279       };
22280     }
22281   }
22282
22283 }
22284
22285
22286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22287   void * jresult ;
22288   Dali::TypeRegistration *arg1 = 0 ;
22289   std::string *arg2 = 0 ;
22290   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22291   Dali::SignalConnectorType *result = 0 ;
22292
22293   arg1 = (Dali::TypeRegistration *)jarg1;
22294   if (!arg1) {
22295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22296     return 0;
22297   }
22298   if (!jarg2) {
22299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22300     return 0;
22301   }
22302   std::string arg2_str(jarg2);
22303   arg2 = &arg2_str;
22304   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22305   {
22306     try {
22307       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22308     } catch (std::out_of_range& e) {
22309       {
22310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22311       };
22312     } catch (std::exception& e) {
22313       {
22314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22315       };
22316     } catch (Dali::DaliException e) {
22317       {
22318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22319       };
22320     } catch (...) {
22321       {
22322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22323       };
22324     }
22325   }
22326
22327   jresult = (void *)result;
22328
22329   //argout typemap for const std::string&
22330
22331   return jresult;
22332 }
22333
22334
22335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22336   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22337
22338   arg1 = (Dali::SignalConnectorType *)jarg1;
22339   {
22340     try {
22341       delete arg1;
22342     } catch (std::out_of_range& e) {
22343       {
22344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22345       };
22346     } catch (std::exception& e) {
22347       {
22348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22349       };
22350     } catch (Dali::DaliException e) {
22351       {
22352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22353       };
22354     } catch (...) {
22355       {
22356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22357       };
22358     }
22359   }
22360
22361 }
22362
22363
22364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22365   void * jresult ;
22366   Dali::TypeRegistration *arg1 = 0 ;
22367   std::string *arg2 = 0 ;
22368   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22369   Dali::TypeAction *result = 0 ;
22370
22371   arg1 = (Dali::TypeRegistration *)jarg1;
22372   if (!arg1) {
22373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22374     return 0;
22375   }
22376   if (!jarg2) {
22377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22378     return 0;
22379   }
22380   std::string arg2_str(jarg2);
22381   arg2 = &arg2_str;
22382   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22383   {
22384     try {
22385       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22386     } catch (std::out_of_range& e) {
22387       {
22388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22389       };
22390     } catch (std::exception& e) {
22391       {
22392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22393       };
22394     } catch (Dali::DaliException e) {
22395       {
22396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22397       };
22398     } catch (...) {
22399       {
22400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22401       };
22402     }
22403   }
22404
22405   jresult = (void *)result;
22406
22407   //argout typemap for const std::string&
22408
22409   return jresult;
22410 }
22411
22412
22413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22414   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22415
22416   arg1 = (Dali::TypeAction *)jarg1;
22417   {
22418     try {
22419       delete arg1;
22420     } catch (std::out_of_range& e) {
22421       {
22422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22423       };
22424     } catch (std::exception& e) {
22425       {
22426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22427       };
22428     } catch (Dali::DaliException e) {
22429       {
22430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22431       };
22432     } catch (...) {
22433       {
22434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22435       };
22436     }
22437   }
22438
22439 }
22440
22441
22442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22443   void * jresult ;
22444   Dali::TypeRegistration *arg1 = 0 ;
22445   std::string *arg2 = 0 ;
22446   Dali::Property::Index arg3 ;
22447   Dali::Property::Type arg4 ;
22448   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22449   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22450   Dali::PropertyRegistration *result = 0 ;
22451
22452   arg1 = (Dali::TypeRegistration *)jarg1;
22453   if (!arg1) {
22454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22455     return 0;
22456   }
22457   if (!jarg2) {
22458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22459     return 0;
22460   }
22461   std::string arg2_str(jarg2);
22462   arg2 = &arg2_str;
22463   arg3 = (Dali::Property::Index)jarg3;
22464   arg4 = (Dali::Property::Type)jarg4;
22465   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22466   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22467   {
22468     try {
22469       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22470     } catch (std::out_of_range& e) {
22471       {
22472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22473       };
22474     } catch (std::exception& e) {
22475       {
22476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22477       };
22478     } catch (Dali::DaliException e) {
22479       {
22480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22481       };
22482     } catch (...) {
22483       {
22484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22485       };
22486     }
22487   }
22488
22489   jresult = (void *)result;
22490
22491   //argout typemap for const std::string&
22492
22493   return jresult;
22494 }
22495
22496
22497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22498   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22499
22500   arg1 = (Dali::PropertyRegistration *)jarg1;
22501   {
22502     try {
22503       delete arg1;
22504     } catch (std::out_of_range& e) {
22505       {
22506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22507       };
22508     } catch (std::exception& e) {
22509       {
22510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22511       };
22512     } catch (Dali::DaliException e) {
22513       {
22514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22515       };
22516     } catch (...) {
22517       {
22518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22519       };
22520     }
22521   }
22522
22523 }
22524
22525
22526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22527   void * jresult ;
22528   Dali::TypeRegistration *arg1 = 0 ;
22529   std::string *arg2 = 0 ;
22530   Dali::Property::Index arg3 ;
22531   Dali::Property::Type arg4 ;
22532   Dali::AnimatablePropertyRegistration *result = 0 ;
22533
22534   arg1 = (Dali::TypeRegistration *)jarg1;
22535   if (!arg1) {
22536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22537     return 0;
22538   }
22539   if (!jarg2) {
22540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22541     return 0;
22542   }
22543   std::string arg2_str(jarg2);
22544   arg2 = &arg2_str;
22545   arg3 = (Dali::Property::Index)jarg3;
22546   arg4 = (Dali::Property::Type)jarg4;
22547   {
22548     try {
22549       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22550     } catch (std::out_of_range& e) {
22551       {
22552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22553       };
22554     } catch (std::exception& e) {
22555       {
22556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22557       };
22558     } catch (Dali::DaliException e) {
22559       {
22560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22561       };
22562     } catch (...) {
22563       {
22564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22565       };
22566     }
22567   }
22568
22569   jresult = (void *)result;
22570
22571   //argout typemap for const std::string&
22572
22573   return jresult;
22574 }
22575
22576
22577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22578   void * jresult ;
22579   Dali::TypeRegistration *arg1 = 0 ;
22580   std::string *arg2 = 0 ;
22581   Dali::Property::Index arg3 ;
22582   Dali::Property::Value *arg4 = 0 ;
22583   Dali::AnimatablePropertyRegistration *result = 0 ;
22584
22585   arg1 = (Dali::TypeRegistration *)jarg1;
22586   if (!arg1) {
22587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22588     return 0;
22589   }
22590   if (!jarg2) {
22591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22592     return 0;
22593   }
22594   std::string arg2_str(jarg2);
22595   arg2 = &arg2_str;
22596   arg3 = (Dali::Property::Index)jarg3;
22597   arg4 = (Dali::Property::Value *)jarg4;
22598   if (!arg4) {
22599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22600     return 0;
22601   }
22602   {
22603     try {
22604       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22605     } catch (std::out_of_range& e) {
22606       {
22607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22608       };
22609     } catch (std::exception& e) {
22610       {
22611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22612       };
22613     } catch (Dali::DaliException e) {
22614       {
22615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22616       };
22617     } catch (...) {
22618       {
22619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22620       };
22621     }
22622   }
22623
22624   jresult = (void *)result;
22625
22626   //argout typemap for const std::string&
22627
22628   return jresult;
22629 }
22630
22631
22632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22633   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22634
22635   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22636   {
22637     try {
22638       delete arg1;
22639     } catch (std::out_of_range& e) {
22640       {
22641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22642       };
22643     } catch (std::exception& e) {
22644       {
22645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22646       };
22647     } catch (Dali::DaliException e) {
22648       {
22649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22650       };
22651     } catch (...) {
22652       {
22653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22654       };
22655     }
22656   }
22657
22658 }
22659
22660
22661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22662   void * jresult ;
22663   Dali::TypeRegistration *arg1 = 0 ;
22664   std::string *arg2 = 0 ;
22665   Dali::Property::Index arg3 ;
22666   Dali::Property::Index arg4 ;
22667   unsigned int arg5 ;
22668   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22669
22670   arg1 = (Dali::TypeRegistration *)jarg1;
22671   if (!arg1) {
22672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22673     return 0;
22674   }
22675   if (!jarg2) {
22676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22677     return 0;
22678   }
22679   std::string arg2_str(jarg2);
22680   arg2 = &arg2_str;
22681   arg3 = (Dali::Property::Index)jarg3;
22682   arg4 = (Dali::Property::Index)jarg4;
22683   arg5 = (unsigned int)jarg5;
22684   {
22685     try {
22686       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22687     } catch (std::out_of_range& e) {
22688       {
22689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22690       };
22691     } catch (std::exception& e) {
22692       {
22693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22694       };
22695     } catch (Dali::DaliException e) {
22696       {
22697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22698       };
22699     } catch (...) {
22700       {
22701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22702       };
22703     }
22704   }
22705
22706   jresult = (void *)result;
22707
22708   //argout typemap for const std::string&
22709
22710   return jresult;
22711 }
22712
22713
22714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22715   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22716
22717   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22718   {
22719     try {
22720       delete arg1;
22721     } catch (std::out_of_range& e) {
22722       {
22723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22724       };
22725     } catch (std::exception& e) {
22726       {
22727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22728       };
22729     } catch (Dali::DaliException e) {
22730       {
22731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22732       };
22733     } catch (...) {
22734       {
22735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22736       };
22737     }
22738   }
22739
22740 }
22741
22742
22743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22744   void * jresult ;
22745   Dali::TypeRegistration *arg1 = 0 ;
22746   std::string *arg2 = 0 ;
22747   Dali::Property::Index arg3 ;
22748   Dali::Property::Type arg4 ;
22749   Dali::ChildPropertyRegistration *result = 0 ;
22750
22751   arg1 = (Dali::TypeRegistration *)jarg1;
22752   if (!arg1) {
22753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22754     return 0;
22755   }
22756   if (!jarg2) {
22757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22758     return 0;
22759   }
22760   std::string arg2_str(jarg2);
22761   arg2 = &arg2_str;
22762   arg3 = (Dali::Property::Index)jarg3;
22763   arg4 = (Dali::Property::Type)jarg4;
22764   {
22765     try {
22766       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22767     } catch (std::out_of_range& e) {
22768       {
22769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22770       };
22771     } catch (std::exception& e) {
22772       {
22773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22774       };
22775     } catch (Dali::DaliException e) {
22776       {
22777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22778       };
22779     } catch (...) {
22780       {
22781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22782       };
22783     }
22784   }
22785
22786   jresult = (void *)result;
22787
22788   //argout typemap for const std::string&
22789
22790   return jresult;
22791 }
22792
22793
22794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22795   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22796
22797   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22798   {
22799     try {
22800       delete arg1;
22801     } catch (std::out_of_range& e) {
22802       {
22803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22804       };
22805     } catch (std::exception& e) {
22806       {
22807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22808       };
22809     } catch (Dali::DaliException e) {
22810       {
22811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22812       };
22813     } catch (...) {
22814       {
22815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22816       };
22817     }
22818   }
22819
22820 }
22821
22822
22823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22824   unsigned int jresult ;
22825   std::string *arg1 = 0 ;
22826   std::type_info *arg2 = 0 ;
22827   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22828   bool result;
22829
22830   if (!jarg1) {
22831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22832     return 0;
22833   }
22834   std::string arg1_str(jarg1);
22835   arg1 = &arg1_str;
22836   arg2 = (std::type_info *)jarg2;
22837   if (!arg2) {
22838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22839     return 0;
22840   }
22841   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22842   {
22843     try {
22844       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22845     } catch (std::out_of_range& e) {
22846       {
22847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22848       };
22849     } catch (std::exception& e) {
22850       {
22851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22852       };
22853     } catch (Dali::DaliException e) {
22854       {
22855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22856       };
22857     } catch (...) {
22858       {
22859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22860       };
22861     }
22862   }
22863
22864   jresult = result;
22865
22866   //argout typemap for const std::string&
22867
22868   return jresult;
22869 }
22870
22871
22872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22873   unsigned int jresult ;
22874   std::string *arg1 = 0 ;
22875   std::string *arg2 = 0 ;
22876   Dali::Property::Index arg3 ;
22877   Dali::Property::Type arg4 ;
22878   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22879   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22880   bool result;
22881
22882   if (!jarg1) {
22883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22884     return 0;
22885   }
22886   std::string arg1_str(jarg1);
22887   arg1 = &arg1_str;
22888   if (!jarg2) {
22889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22890     return 0;
22891   }
22892   std::string arg2_str(jarg2);
22893   arg2 = &arg2_str;
22894   arg3 = (Dali::Property::Index)jarg3;
22895   arg4 = (Dali::Property::Type)jarg4;
22896   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22897   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22898   {
22899     try {
22900       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22901     } catch (std::out_of_range& e) {
22902       {
22903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22904       };
22905     } catch (std::exception& e) {
22906       {
22907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22908       };
22909     } catch (Dali::DaliException e) {
22910       {
22911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22912       };
22913     } catch (...) {
22914       {
22915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22916       };
22917     }
22918   }
22919
22920   jresult = result;
22921
22922   //argout typemap for const std::string&
22923
22924
22925   //argout typemap for const std::string&
22926
22927   return jresult;
22928 }
22929
22930
22931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22932   float jresult ;
22933   float result;
22934
22935   result = (float)(float)Dali::ParentOrigin::TOP;
22936   jresult = result;
22937   return jresult;
22938 }
22939
22940
22941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22942   float jresult ;
22943   float result;
22944
22945   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22946   jresult = result;
22947   return jresult;
22948 }
22949
22950
22951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22952   float jresult ;
22953   float result;
22954
22955   result = (float)(float)Dali::ParentOrigin::LEFT;
22956   jresult = result;
22957   return jresult;
22958 }
22959
22960
22961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22962   float jresult ;
22963   float result;
22964
22965   result = (float)(float)Dali::ParentOrigin::RIGHT;
22966   jresult = result;
22967   return jresult;
22968 }
22969
22970
22971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22972   float jresult ;
22973   float result;
22974
22975   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22976   jresult = result;
22977   return jresult;
22978 }
22979
22980
22981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22982   void * jresult ;
22983   Dali::Vector3 *result = 0 ;
22984
22985   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22986   jresult = (void *)result;
22987   return jresult;
22988 }
22989
22990
22991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22992   void * jresult ;
22993   Dali::Vector3 *result = 0 ;
22994
22995   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22996   jresult = (void *)result;
22997   return jresult;
22998 }
22999
23000
23001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23002   void * jresult ;
23003   Dali::Vector3 *result = 0 ;
23004
23005   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23006   jresult = (void *)result;
23007   return jresult;
23008 }
23009
23010
23011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23012   void * jresult ;
23013   Dali::Vector3 *result = 0 ;
23014
23015   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23016   jresult = (void *)result;
23017   return jresult;
23018 }
23019
23020
23021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23022   void * jresult ;
23023   Dali::Vector3 *result = 0 ;
23024
23025   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23026   jresult = (void *)result;
23027   return jresult;
23028 }
23029
23030
23031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23032   void * jresult ;
23033   Dali::Vector3 *result = 0 ;
23034
23035   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23036   jresult = (void *)result;
23037   return jresult;
23038 }
23039
23040
23041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23042   void * jresult ;
23043   Dali::Vector3 *result = 0 ;
23044
23045   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23046   jresult = (void *)result;
23047   return jresult;
23048 }
23049
23050
23051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23052   void * jresult ;
23053   Dali::Vector3 *result = 0 ;
23054
23055   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23056   jresult = (void *)result;
23057   return jresult;
23058 }
23059
23060
23061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23062   void * jresult ;
23063   Dali::Vector3 *result = 0 ;
23064
23065   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23066   jresult = (void *)result;
23067   return jresult;
23068 }
23069
23070
23071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23072   float jresult ;
23073   float result;
23074
23075   result = (float)(float)Dali::AnchorPoint::TOP;
23076   jresult = result;
23077   return jresult;
23078 }
23079
23080
23081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23082   float jresult ;
23083   float result;
23084
23085   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23086   jresult = result;
23087   return jresult;
23088 }
23089
23090
23091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23092   float jresult ;
23093   float result;
23094
23095   result = (float)(float)Dali::AnchorPoint::LEFT;
23096   jresult = result;
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23102   float jresult ;
23103   float result;
23104
23105   result = (float)(float)Dali::AnchorPoint::RIGHT;
23106   jresult = result;
23107   return jresult;
23108 }
23109
23110
23111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23112   float jresult ;
23113   float result;
23114
23115   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23116   jresult = result;
23117   return jresult;
23118 }
23119
23120
23121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23122   void * jresult ;
23123   Dali::Vector3 *result = 0 ;
23124
23125   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23126   jresult = (void *)result;
23127   return jresult;
23128 }
23129
23130
23131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23132   void * jresult ;
23133   Dali::Vector3 *result = 0 ;
23134
23135   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23136   jresult = (void *)result;
23137   return jresult;
23138 }
23139
23140
23141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23142   void * jresult ;
23143   Dali::Vector3 *result = 0 ;
23144
23145   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23146   jresult = (void *)result;
23147   return jresult;
23148 }
23149
23150
23151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23152   void * jresult ;
23153   Dali::Vector3 *result = 0 ;
23154
23155   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23156   jresult = (void *)result;
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23162   void * jresult ;
23163   Dali::Vector3 *result = 0 ;
23164
23165   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23166   jresult = (void *)result;
23167   return jresult;
23168 }
23169
23170
23171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23172   void * jresult ;
23173   Dali::Vector3 *result = 0 ;
23174
23175   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23176   jresult = (void *)result;
23177   return jresult;
23178 }
23179
23180
23181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23182   void * jresult ;
23183   Dali::Vector3 *result = 0 ;
23184
23185   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23186   jresult = (void *)result;
23187   return jresult;
23188 }
23189
23190
23191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23192   void * jresult ;
23193   Dali::Vector3 *result = 0 ;
23194
23195   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23196   jresult = (void *)result;
23197   return jresult;
23198 }
23199
23200
23201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23202   void * jresult ;
23203   Dali::Vector3 *result = 0 ;
23204
23205   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23206   jresult = (void *)result;
23207   return jresult;
23208 }
23209
23210
23211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23212   void * jresult ;
23213   Dali::Vector4 *result = 0 ;
23214
23215   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23216   jresult = (void *)result;
23217   return jresult;
23218 }
23219
23220
23221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23222   void * jresult ;
23223   Dali::Vector4 *result = 0 ;
23224
23225   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23226   jresult = (void *)result;
23227   return jresult;
23228 }
23229
23230
23231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23232   void * jresult ;
23233   Dali::Vector4 *result = 0 ;
23234
23235   result = (Dali::Vector4 *)&Dali::Color::RED;
23236   jresult = (void *)result;
23237   return jresult;
23238 }
23239
23240
23241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23242   void * jresult ;
23243   Dali::Vector4 *result = 0 ;
23244
23245   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23246   jresult = (void *)result;
23247   return jresult;
23248 }
23249
23250
23251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23252   void * jresult ;
23253   Dali::Vector4 *result = 0 ;
23254
23255   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23256   jresult = (void *)result;
23257   return jresult;
23258 }
23259
23260
23261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23262   void * jresult ;
23263   Dali::Vector4 *result = 0 ;
23264
23265   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23266   jresult = (void *)result;
23267   return jresult;
23268 }
23269
23270
23271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23272   void * jresult ;
23273   Dali::Vector4 *result = 0 ;
23274
23275   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23276   jresult = (void *)result;
23277   return jresult;
23278 }
23279
23280
23281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23282   void * jresult ;
23283   Dali::Vector4 *result = 0 ;
23284
23285   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23286   jresult = (void *)result;
23287   return jresult;
23288 }
23289
23290
23291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23292   void * jresult ;
23293   Dali::Vector4 *result = 0 ;
23294
23295   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23296   jresult = (void *)result;
23297   return jresult;
23298 }
23299
23300
23301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23302   float jresult ;
23303   float result;
23304
23305   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23306   jresult = result;
23307   return jresult;
23308 }
23309
23310
23311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23312   float jresult ;
23313   float result;
23314
23315   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23316   jresult = result;
23317   return jresult;
23318 }
23319
23320
23321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23322   float jresult ;
23323   float result;
23324
23325   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23326   jresult = result;
23327   return jresult;
23328 }
23329
23330
23331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23332   float jresult ;
23333   float result;
23334
23335   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23336   jresult = result;
23337   return jresult;
23338 }
23339
23340
23341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23342   float jresult ;
23343   float result;
23344
23345   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23346   jresult = result;
23347   return jresult;
23348 }
23349
23350
23351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23352   float jresult ;
23353   float result;
23354
23355   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23356   jresult = result;
23357   return jresult;
23358 }
23359
23360
23361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23362   float jresult ;
23363   float result;
23364
23365   result = (float)(float)Dali::Math::PI;
23366   jresult = result;
23367   return jresult;
23368 }
23369
23370
23371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23372   float jresult ;
23373   float result;
23374
23375   result = (float)(float)Dali::Math::PI_2;
23376   jresult = result;
23377   return jresult;
23378 }
23379
23380
23381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23382   float jresult ;
23383   float result;
23384
23385   result = (float)(float)Dali::Math::PI_4;
23386   jresult = result;
23387   return jresult;
23388 }
23389
23390
23391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23392   float jresult ;
23393   float result;
23394
23395   result = (float)(float)Dali::Math::PI_OVER_180;
23396   jresult = result;
23397   return jresult;
23398 }
23399
23400
23401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23402   float jresult ;
23403   float result;
23404
23405   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23406   jresult = result;
23407   return jresult;
23408 }
23409
23410
23411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23412   int jresult ;
23413   Dali::ResizePolicy::Type result;
23414
23415   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23416   jresult = (int)result;
23417   return jresult;
23418 }
23419
23420
23421 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23422   unsigned long jresult ;
23423   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23424   Dali::VectorBase::SizeType result;
23425
23426   arg1 = (Dali::VectorBase *)jarg1;
23427   {
23428     try {
23429       result = ((Dali::VectorBase const *)arg1)->Count();
23430     } catch (std::out_of_range& e) {
23431       {
23432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23433       };
23434     } catch (std::exception& e) {
23435       {
23436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23437       };
23438     } catch (Dali::DaliException e) {
23439       {
23440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23441       };
23442     } catch (...) {
23443       {
23444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23445       };
23446     }
23447   }
23448
23449   jresult = (unsigned long)result;
23450   return jresult;
23451 }
23452
23453
23454 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23455   unsigned long jresult ;
23456   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23457   Dali::VectorBase::SizeType result;
23458
23459   arg1 = (Dali::VectorBase *)jarg1;
23460   {
23461     try {
23462       result = ((Dali::VectorBase const *)arg1)->Size();
23463     } catch (std::out_of_range& e) {
23464       {
23465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23466       };
23467     } catch (std::exception& e) {
23468       {
23469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23470       };
23471     } catch (Dali::DaliException e) {
23472       {
23473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23474       };
23475     } catch (...) {
23476       {
23477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23478       };
23479     }
23480   }
23481
23482   jresult = (unsigned long)result;
23483   return jresult;
23484 }
23485
23486
23487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23488   unsigned int jresult ;
23489   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23490   bool result;
23491
23492   arg1 = (Dali::VectorBase *)jarg1;
23493   {
23494     try {
23495       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23496     } catch (std::out_of_range& e) {
23497       {
23498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23499       };
23500     } catch (std::exception& e) {
23501       {
23502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23503       };
23504     } catch (Dali::DaliException e) {
23505       {
23506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23507       };
23508     } catch (...) {
23509       {
23510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23511       };
23512     }
23513   }
23514
23515   jresult = result;
23516   return jresult;
23517 }
23518
23519
23520 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23521   unsigned long jresult ;
23522   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23523   Dali::VectorBase::SizeType result;
23524
23525   arg1 = (Dali::VectorBase *)jarg1;
23526   {
23527     try {
23528       result = ((Dali::VectorBase const *)arg1)->Capacity();
23529     } catch (std::out_of_range& e) {
23530       {
23531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23532       };
23533     } catch (std::exception& e) {
23534       {
23535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23536       };
23537     } catch (Dali::DaliException e) {
23538       {
23539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23540       };
23541     } catch (...) {
23542       {
23543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23544       };
23545     }
23546   }
23547
23548   jresult = (unsigned long)result;
23549   return jresult;
23550 }
23551
23552
23553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23554   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23555
23556   arg1 = (Dali::VectorBase *)jarg1;
23557   {
23558     try {
23559       (arg1)->Release();
23560     } catch (std::out_of_range& e) {
23561       {
23562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23563       };
23564     } catch (std::exception& e) {
23565       {
23566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23567       };
23568     } catch (Dali::DaliException e) {
23569       {
23570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23571       };
23572     } catch (...) {
23573       {
23574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23575       };
23576     }
23577   }
23578
23579 }
23580
23581
23582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23583   int jresult ;
23584   Dali::Pixel::Format result;
23585
23586   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23587   jresult = (int)result;
23588   return jresult;
23589 }
23590
23591
23592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23593   int jresult ;
23594   Dali::Pixel::Format result;
23595
23596   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23597   jresult = (int)result;
23598   return jresult;
23599 }
23600
23601
23602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23603   unsigned int jresult ;
23604   Dali::Pixel::Format arg1 ;
23605   bool result;
23606
23607   arg1 = (Dali::Pixel::Format)jarg1;
23608   {
23609     try {
23610       result = (bool)Dali::Pixel::HasAlpha(arg1);
23611     } catch (std::out_of_range& e) {
23612       {
23613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23614       };
23615     } catch (std::exception& e) {
23616       {
23617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23618       };
23619     } catch (Dali::DaliException e) {
23620       {
23621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23622       };
23623     } catch (...) {
23624       {
23625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23626       };
23627     }
23628   }
23629
23630   jresult = result;
23631   return jresult;
23632 }
23633
23634
23635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23636   unsigned int jresult ;
23637   Dali::Pixel::Format arg1 ;
23638   unsigned int result;
23639
23640   arg1 = (Dali::Pixel::Format)jarg1;
23641   {
23642     try {
23643       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23644     } catch (std::out_of_range& e) {
23645       {
23646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23647       };
23648     } catch (std::exception& e) {
23649       {
23650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23651       };
23652     } catch (Dali::DaliException e) {
23653       {
23654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23655       };
23656     } catch (...) {
23657       {
23658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23659       };
23660     }
23661   }
23662
23663   jresult = result;
23664   return jresult;
23665 }
23666
23667
23668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23669   Dali::Pixel::Format arg1 ;
23670   int *arg2 = 0 ;
23671   int *arg3 = 0 ;
23672
23673   arg1 = (Dali::Pixel::Format)jarg1;
23674   arg2 = (int *)jarg2;
23675   if (!arg2) {
23676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23677     return ;
23678   }
23679   arg3 = (int *)jarg3;
23680   if (!arg3) {
23681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23682     return ;
23683   }
23684   {
23685     try {
23686       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23687     } catch (std::out_of_range& e) {
23688       {
23689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23690       };
23691     } catch (std::exception& e) {
23692       {
23693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23694       };
23695     } catch (Dali::DaliException e) {
23696       {
23697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23698       };
23699     } catch (...) {
23700       {
23701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23702       };
23703     }
23704   }
23705
23706 }
23707
23708
23709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23710   void * jresult ;
23711   unsigned char *arg1 = (unsigned char *) 0 ;
23712   unsigned int arg2 ;
23713   unsigned int arg3 ;
23714   unsigned int arg4 ;
23715   Dali::Pixel::Format arg5 ;
23716   Dali::PixelData::ReleaseFunction arg6 ;
23717   Dali::PixelData result;
23718
23719   arg1 = jarg1;
23720   arg2 = (unsigned int)jarg2;
23721   arg3 = (unsigned int)jarg3;
23722   arg4 = (unsigned int)jarg4;
23723   arg5 = (Dali::Pixel::Format)jarg5;
23724   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23725   {
23726     try {
23727       auto pixelBuffer = new unsigned char[jarg2];
23728       memcpy( pixelBuffer, arg1, arg2);
23729       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23730     } catch (std::out_of_range& e) {
23731       {
23732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23733       };
23734     } catch (std::exception& e) {
23735       {
23736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23737       };
23738     } catch (Dali::DaliException e) {
23739       {
23740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23741       };
23742     } catch (...) {
23743       {
23744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23745       };
23746     }
23747   }
23748
23749   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23750
23751
23752   return jresult;
23753 }
23754
23755
23756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23757   void * jresult ;
23758   Dali::PixelData *result = 0 ;
23759
23760   {
23761     try {
23762       result = (Dali::PixelData *)new Dali::PixelData();
23763     } catch (std::out_of_range& e) {
23764       {
23765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23766       };
23767     } catch (std::exception& e) {
23768       {
23769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23770       };
23771     } catch (Dali::DaliException e) {
23772       {
23773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23774       };
23775     } catch (...) {
23776       {
23777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23778       };
23779     }
23780   }
23781
23782   jresult = (void *)result;
23783   return jresult;
23784 }
23785
23786
23787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23788   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23789
23790   arg1 = (Dali::PixelData *)jarg1;
23791   {
23792     try {
23793       delete arg1;
23794     } catch (std::out_of_range& e) {
23795       {
23796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23797       };
23798     } catch (std::exception& e) {
23799       {
23800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23801       };
23802     } catch (Dali::DaliException e) {
23803       {
23804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23805       };
23806     } catch (...) {
23807       {
23808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23809       };
23810     }
23811   }
23812
23813 }
23814
23815
23816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23817   void * jresult ;
23818   Dali::PixelData *arg1 = 0 ;
23819   Dali::PixelData *result = 0 ;
23820
23821   arg1 = (Dali::PixelData *)jarg1;
23822   if (!arg1) {
23823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23824     return 0;
23825   }
23826   {
23827     try {
23828       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23829     } catch (std::out_of_range& e) {
23830       {
23831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23832       };
23833     } catch (std::exception& e) {
23834       {
23835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23836       };
23837     } catch (Dali::DaliException e) {
23838       {
23839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23840       };
23841     } catch (...) {
23842       {
23843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23844       };
23845     }
23846   }
23847
23848   jresult = (void *)result;
23849   return jresult;
23850 }
23851
23852
23853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23854   void * jresult ;
23855   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23856   Dali::PixelData *arg2 = 0 ;
23857   Dali::PixelData *result = 0 ;
23858
23859   arg1 = (Dali::PixelData *)jarg1;
23860   arg2 = (Dali::PixelData *)jarg2;
23861   if (!arg2) {
23862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23863     return 0;
23864   }
23865   {
23866     try {
23867       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23868     } catch (std::out_of_range& e) {
23869       {
23870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23871       };
23872     } catch (std::exception& e) {
23873       {
23874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23875       };
23876     } catch (Dali::DaliException e) {
23877       {
23878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23879       };
23880     } catch (...) {
23881       {
23882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23883       };
23884     }
23885   }
23886
23887   jresult = (void *)result;
23888   return jresult;
23889 }
23890
23891
23892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23893   unsigned int jresult ;
23894   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23895   unsigned int result;
23896
23897   arg1 = (Dali::PixelData *)jarg1;
23898   {
23899     try {
23900       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23901     } catch (std::out_of_range& e) {
23902       {
23903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23904       };
23905     } catch (std::exception& e) {
23906       {
23907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23908       };
23909     } catch (Dali::DaliException e) {
23910       {
23911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23912       };
23913     } catch (...) {
23914       {
23915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23916       };
23917     }
23918   }
23919
23920   jresult = result;
23921   return jresult;
23922 }
23923
23924
23925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23926   unsigned int jresult ;
23927   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23928   unsigned int result;
23929
23930   arg1 = (Dali::PixelData *)jarg1;
23931   {
23932     try {
23933       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23934     } catch (std::out_of_range& e) {
23935       {
23936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23937       };
23938     } catch (std::exception& e) {
23939       {
23940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23941       };
23942     } catch (Dali::DaliException e) {
23943       {
23944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23945       };
23946     } catch (...) {
23947       {
23948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23949       };
23950     }
23951   }
23952
23953   jresult = result;
23954   return jresult;
23955 }
23956
23957
23958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23959   int jresult ;
23960   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23961   Dali::Pixel::Format result;
23962
23963   arg1 = (Dali::PixelData *)jarg1;
23964   {
23965     try {
23966       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23967     } catch (std::out_of_range& e) {
23968       {
23969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23970       };
23971     } catch (std::exception& e) {
23972       {
23973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23974       };
23975     } catch (Dali::DaliException e) {
23976       {
23977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23978       };
23979     } catch (...) {
23980       {
23981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23982       };
23983     }
23984   }
23985
23986   jresult = (int)result;
23987   return jresult;
23988 }
23989
23990
23991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
23992   unsigned int jresult ;
23993   unsigned int result;
23994
23995   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
23996   jresult = result;
23997   return jresult;
23998 }
23999
24000
24001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24002   unsigned int jresult ;
24003   unsigned int result;
24004
24005   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24006   jresult = result;
24007   return jresult;
24008 }
24009
24010
24011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24012   unsigned int jresult ;
24013   unsigned int result;
24014
24015   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24016   jresult = result;
24017   return jresult;
24018 }
24019
24020
24021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24022   unsigned int jresult ;
24023   unsigned int result;
24024
24025   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24026   jresult = result;
24027   return jresult;
24028 }
24029
24030
24031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24032   unsigned int jresult ;
24033   unsigned int result;
24034
24035   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24036   jresult = result;
24037   return jresult;
24038 }
24039
24040
24041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24042   unsigned int jresult ;
24043   unsigned int result;
24044
24045   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24046   jresult = result;
24047   return jresult;
24048 }
24049
24050
24051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24052   void * jresult ;
24053   Dali::TextureType::Type arg1 ;
24054   Dali::Pixel::Format arg2 ;
24055   unsigned int arg3 ;
24056   unsigned int arg4 ;
24057   Dali::Texture result;
24058
24059   arg1 = (Dali::TextureType::Type)jarg1;
24060   arg2 = (Dali::Pixel::Format)jarg2;
24061   arg3 = (unsigned int)jarg3;
24062   arg4 = (unsigned int)jarg4;
24063   {
24064     try {
24065       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24066     } catch (std::out_of_range& e) {
24067       {
24068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24069       };
24070     } catch (std::exception& e) {
24071       {
24072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24073       };
24074     } catch (Dali::DaliException e) {
24075       {
24076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24077       };
24078     } catch (...) {
24079       {
24080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24081       };
24082     }
24083   }
24084
24085   jresult = new Dali::Texture((const Dali::Texture &)result);
24086   return jresult;
24087 }
24088
24089
24090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24091   void * jresult ;
24092   NativeImageInterface *arg1 = 0 ;
24093   Dali::Texture result;
24094
24095   arg1 = (NativeImageInterface *)jarg1;
24096   if (!arg1) {
24097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24098     return 0;
24099   }
24100   {
24101     try {
24102       result = Dali::Texture::New(*arg1);
24103     } catch (std::out_of_range& e) {
24104       {
24105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24106       };
24107     } catch (std::exception& e) {
24108       {
24109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24110       };
24111     } catch (Dali::DaliException e) {
24112       {
24113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24114       };
24115     } catch (...) {
24116       {
24117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24118       };
24119     }
24120   }
24121
24122   jresult = new Dali::Texture((const Dali::Texture &)result);
24123   return jresult;
24124 }
24125
24126
24127 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Texture_TbmSurface(tbm_surface_h tbm_surface) {
24128   Dali::NativeImageSourcePtr mNativeImageSrc;
24129   Dali::Texture mNativeTexture;
24130   void * jresult ;
24131
24132   if (!tbm_surface) {
24133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "tbm surface is null", 0);
24134     return 0;
24135   }
24136
24137   try {
24138     Dali::Any source(tbm_surface);
24139     mNativeImageSrc = Dali::NativeImageSource::New(source);
24140     mNativeTexture = Dali::Texture::New( *mNativeImageSrc );
24141     } catch (std::out_of_range& e) {
24142       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
24143       return 0;
24144     } catch (std::exception& e) {
24145       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
24146       return 0;
24147     } catch (Dali::DaliException e) {
24148       SWIG_CSharpException(SWIG_UnknownError, e.condition);
24149       return 0;
24150     } catch (...) {
24151       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
24152       return 0;
24153   }
24154
24155   jresult = new Dali::Texture((const Dali::Texture &)mNativeTexture);
24156   return (void*)jresult;
24157 }
24158
24159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24160   void * jresult ;
24161   Dali::Texture *result = 0 ;
24162
24163   {
24164     try {
24165       result = (Dali::Texture *)new Dali::Texture();
24166     } catch (std::out_of_range& e) {
24167       {
24168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24169       };
24170     } catch (std::exception& e) {
24171       {
24172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24173       };
24174     } catch (Dali::DaliException e) {
24175       {
24176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24177       };
24178     } catch (...) {
24179       {
24180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24181       };
24182     }
24183   }
24184
24185   jresult = (void *)result;
24186   return jresult;
24187 }
24188
24189
24190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24191   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24192
24193   arg1 = (Dali::Texture *)jarg1;
24194   {
24195     try {
24196       delete arg1;
24197     } catch (std::out_of_range& e) {
24198       {
24199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24200       };
24201     } catch (std::exception& e) {
24202       {
24203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24204       };
24205     } catch (Dali::DaliException e) {
24206       {
24207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24208       };
24209     } catch (...) {
24210       {
24211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24212       };
24213     }
24214   }
24215
24216 }
24217
24218
24219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24220   void * jresult ;
24221   Dali::Texture *arg1 = 0 ;
24222   Dali::Texture *result = 0 ;
24223
24224   arg1 = (Dali::Texture *)jarg1;
24225   if (!arg1) {
24226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24227     return 0;
24228   }
24229   {
24230     try {
24231       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24232     } catch (std::out_of_range& e) {
24233       {
24234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24235       };
24236     } catch (std::exception& e) {
24237       {
24238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24239       };
24240     } catch (Dali::DaliException e) {
24241       {
24242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24243       };
24244     } catch (...) {
24245       {
24246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24247       };
24248     }
24249   }
24250
24251   jresult = (void *)result;
24252   return jresult;
24253 }
24254
24255
24256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24257   void * jresult ;
24258   Dali::BaseHandle arg1 ;
24259   Dali::BaseHandle *argp1 ;
24260   Dali::Texture result;
24261
24262   argp1 = (Dali::BaseHandle *)jarg1;
24263   if (!argp1) {
24264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24265     return 0;
24266   }
24267   arg1 = *argp1;
24268   {
24269     try {
24270       result = Dali::Texture::DownCast(arg1);
24271     } catch (std::out_of_range& e) {
24272       {
24273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24274       };
24275     } catch (std::exception& e) {
24276       {
24277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24278       };
24279     } catch (Dali::DaliException e) {
24280       {
24281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24282       };
24283     } catch (...) {
24284       {
24285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24286       };
24287     }
24288   }
24289
24290   jresult = new Dali::Texture((const Dali::Texture &)result);
24291   return jresult;
24292 }
24293
24294
24295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24296   void * jresult ;
24297   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24298   Dali::Texture *arg2 = 0 ;
24299   Dali::Texture *result = 0 ;
24300
24301   arg1 = (Dali::Texture *)jarg1;
24302   arg2 = (Dali::Texture *)jarg2;
24303   if (!arg2) {
24304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24305     return 0;
24306   }
24307   {
24308     try {
24309       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24310     } catch (std::out_of_range& e) {
24311       {
24312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24313       };
24314     } catch (std::exception& e) {
24315       {
24316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24317       };
24318     } catch (Dali::DaliException e) {
24319       {
24320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24321       };
24322     } catch (...) {
24323       {
24324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24325       };
24326     }
24327   }
24328
24329   jresult = (void *)result;
24330   return jresult;
24331 }
24332
24333
24334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24335   unsigned int jresult ;
24336   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24337   Dali::PixelData arg2 ;
24338   Dali::PixelData *argp2 ;
24339   bool result;
24340
24341   arg1 = (Dali::Texture *)jarg1;
24342   argp2 = (Dali::PixelData *)jarg2;
24343   if (!argp2) {
24344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24345     return 0;
24346   }
24347   arg2 = *argp2;
24348   {
24349     try {
24350       result = (bool)(arg1)->Upload(arg2);
24351     } catch (std::out_of_range& e) {
24352       {
24353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24354       };
24355     } catch (std::exception& e) {
24356       {
24357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24358       };
24359     } catch (Dali::DaliException e) {
24360       {
24361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24362       };
24363     } catch (...) {
24364       {
24365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24366       };
24367     }
24368   }
24369
24370   jresult = result;
24371   return jresult;
24372 }
24373
24374
24375 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) {
24376   unsigned int jresult ;
24377   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24378   Dali::PixelData arg2 ;
24379   unsigned int arg3 ;
24380   unsigned int arg4 ;
24381   unsigned int arg5 ;
24382   unsigned int arg6 ;
24383   unsigned int arg7 ;
24384   unsigned int arg8 ;
24385   Dali::PixelData *argp2 ;
24386   bool result;
24387
24388   arg1 = (Dali::Texture *)jarg1;
24389   argp2 = (Dali::PixelData *)jarg2;
24390   if (!argp2) {
24391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24392     return 0;
24393   }
24394   arg2 = *argp2;
24395   arg3 = (unsigned int)jarg3;
24396   arg4 = (unsigned int)jarg4;
24397   arg5 = (unsigned int)jarg5;
24398   arg6 = (unsigned int)jarg6;
24399   arg7 = (unsigned int)jarg7;
24400   arg8 = (unsigned int)jarg8;
24401   {
24402     try {
24403       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24404     } catch (std::out_of_range& e) {
24405       {
24406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24407       };
24408     } catch (std::exception& e) {
24409       {
24410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24411       };
24412     } catch (Dali::DaliException e) {
24413       {
24414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24415       };
24416     } catch (...) {
24417       {
24418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24419       };
24420     }
24421   }
24422
24423   jresult = result;
24424   return jresult;
24425 }
24426
24427
24428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24429   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24430
24431   arg1 = (Dali::Texture *)jarg1;
24432   {
24433     try {
24434       (arg1)->GenerateMipmaps();
24435     } catch (std::out_of_range& e) {
24436       {
24437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24438       };
24439     } catch (std::exception& e) {
24440       {
24441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24442       };
24443     } catch (Dali::DaliException e) {
24444       {
24445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24446       };
24447     } catch (...) {
24448       {
24449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24450       };
24451     }
24452   }
24453
24454 }
24455
24456
24457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24458   unsigned int jresult ;
24459   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24460   unsigned int result;
24461
24462   arg1 = (Dali::Texture *)jarg1;
24463   {
24464     try {
24465       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24466     } catch (std::out_of_range& e) {
24467       {
24468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24469       };
24470     } catch (std::exception& e) {
24471       {
24472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24473       };
24474     } catch (Dali::DaliException e) {
24475       {
24476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24477       };
24478     } catch (...) {
24479       {
24480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24481       };
24482     }
24483   }
24484
24485   jresult = result;
24486   return jresult;
24487 }
24488
24489
24490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24491   unsigned int jresult ;
24492   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24493   unsigned int result;
24494
24495   arg1 = (Dali::Texture *)jarg1;
24496   {
24497     try {
24498       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24499     } catch (std::out_of_range& e) {
24500       {
24501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24502       };
24503     } catch (std::exception& e) {
24504       {
24505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24506       };
24507     } catch (Dali::DaliException e) {
24508       {
24509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24510       };
24511     } catch (...) {
24512       {
24513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24514       };
24515     }
24516   }
24517
24518   jresult = result;
24519   return jresult;
24520 }
24521
24522
24523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24524   void * jresult ;
24525   Dali::Sampler result;
24526
24527   {
24528     try {
24529       result = Dali::Sampler::New();
24530     } catch (std::out_of_range& e) {
24531       {
24532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24533       };
24534     } catch (std::exception& e) {
24535       {
24536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24537       };
24538     } catch (Dali::DaliException e) {
24539       {
24540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24541       };
24542     } catch (...) {
24543       {
24544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24545       };
24546     }
24547   }
24548
24549   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24550   return jresult;
24551 }
24552
24553
24554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24555   void * jresult ;
24556   Dali::Sampler *result = 0 ;
24557
24558   {
24559     try {
24560       result = (Dali::Sampler *)new Dali::Sampler();
24561     } catch (std::out_of_range& e) {
24562       {
24563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24564       };
24565     } catch (std::exception& e) {
24566       {
24567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24568       };
24569     } catch (Dali::DaliException e) {
24570       {
24571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24572       };
24573     } catch (...) {
24574       {
24575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24576       };
24577     }
24578   }
24579
24580   jresult = (void *)result;
24581   return jresult;
24582 }
24583
24584
24585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24586   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24587
24588   arg1 = (Dali::Sampler *)jarg1;
24589   {
24590     try {
24591       delete arg1;
24592     } catch (std::out_of_range& e) {
24593       {
24594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24595       };
24596     } catch (std::exception& e) {
24597       {
24598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24599       };
24600     } catch (Dali::DaliException e) {
24601       {
24602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24603       };
24604     } catch (...) {
24605       {
24606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24607       };
24608     }
24609   }
24610
24611 }
24612
24613
24614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24615   void * jresult ;
24616   Dali::Sampler *arg1 = 0 ;
24617   Dali::Sampler *result = 0 ;
24618
24619   arg1 = (Dali::Sampler *)jarg1;
24620   if (!arg1) {
24621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24622     return 0;
24623   }
24624   {
24625     try {
24626       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24627     } catch (std::out_of_range& e) {
24628       {
24629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24630       };
24631     } catch (std::exception& e) {
24632       {
24633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24634       };
24635     } catch (Dali::DaliException e) {
24636       {
24637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24638       };
24639     } catch (...) {
24640       {
24641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24642       };
24643     }
24644   }
24645
24646   jresult = (void *)result;
24647   return jresult;
24648 }
24649
24650
24651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24652   void * jresult ;
24653   Dali::BaseHandle arg1 ;
24654   Dali::BaseHandle *argp1 ;
24655   Dali::Sampler result;
24656
24657   argp1 = (Dali::BaseHandle *)jarg1;
24658   if (!argp1) {
24659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24660     return 0;
24661   }
24662   arg1 = *argp1;
24663   {
24664     try {
24665       result = Dali::Sampler::DownCast(arg1);
24666     } catch (std::out_of_range& e) {
24667       {
24668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24669       };
24670     } catch (std::exception& e) {
24671       {
24672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24673       };
24674     } catch (Dali::DaliException e) {
24675       {
24676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24677       };
24678     } catch (...) {
24679       {
24680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24681       };
24682     }
24683   }
24684
24685   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24686   return jresult;
24687 }
24688
24689
24690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24691   void * jresult ;
24692   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24693   Dali::Sampler *arg2 = 0 ;
24694   Dali::Sampler *result = 0 ;
24695
24696   arg1 = (Dali::Sampler *)jarg1;
24697   arg2 = (Dali::Sampler *)jarg2;
24698   if (!arg2) {
24699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24700     return 0;
24701   }
24702   {
24703     try {
24704       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24705     } catch (std::out_of_range& e) {
24706       {
24707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24708       };
24709     } catch (std::exception& e) {
24710       {
24711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24712       };
24713     } catch (Dali::DaliException e) {
24714       {
24715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24716       };
24717     } catch (...) {
24718       {
24719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24720       };
24721     }
24722   }
24723
24724   jresult = (void *)result;
24725   return jresult;
24726 }
24727
24728
24729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24730   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24731   Dali::FilterMode::Type arg2 ;
24732   Dali::FilterMode::Type arg3 ;
24733
24734   arg1 = (Dali::Sampler *)jarg1;
24735   arg2 = (Dali::FilterMode::Type)jarg2;
24736   arg3 = (Dali::FilterMode::Type)jarg3;
24737   {
24738     try {
24739       (arg1)->SetFilterMode(arg2,arg3);
24740     } catch (std::out_of_range& e) {
24741       {
24742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24743       };
24744     } catch (std::exception& e) {
24745       {
24746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24747       };
24748     } catch (Dali::DaliException e) {
24749       {
24750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24751       };
24752     } catch (...) {
24753       {
24754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24755       };
24756     }
24757   }
24758
24759 }
24760
24761
24762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24763   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24764   Dali::WrapMode::Type arg2 ;
24765   Dali::WrapMode::Type arg3 ;
24766
24767   arg1 = (Dali::Sampler *)jarg1;
24768   arg2 = (Dali::WrapMode::Type)jarg2;
24769   arg3 = (Dali::WrapMode::Type)jarg3;
24770   {
24771     try {
24772       (arg1)->SetWrapMode(arg2,arg3);
24773     } catch (std::out_of_range& e) {
24774       {
24775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24776       };
24777     } catch (std::exception& e) {
24778       {
24779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24780       };
24781     } catch (Dali::DaliException e) {
24782       {
24783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24784       };
24785     } catch (...) {
24786       {
24787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24788       };
24789     }
24790   }
24791
24792 }
24793
24794
24795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24796   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24797   Dali::WrapMode::Type arg2 ;
24798   Dali::WrapMode::Type arg3 ;
24799   Dali::WrapMode::Type arg4 ;
24800
24801   arg1 = (Dali::Sampler *)jarg1;
24802   arg2 = (Dali::WrapMode::Type)jarg2;
24803   arg3 = (Dali::WrapMode::Type)jarg3;
24804   arg4 = (Dali::WrapMode::Type)jarg4;
24805   {
24806     try {
24807       (arg1)->SetWrapMode(arg2,arg3,arg4);
24808     } catch (std::out_of_range& e) {
24809       {
24810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24811       };
24812     } catch (std::exception& e) {
24813       {
24814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24815       };
24816     } catch (Dali::DaliException e) {
24817       {
24818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24819       };
24820     } catch (...) {
24821       {
24822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24823       };
24824     }
24825   }
24826
24827 }
24828
24829
24830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24831   void * jresult ;
24832   Dali::TextureSet result;
24833
24834   {
24835     try {
24836       result = Dali::TextureSet::New();
24837     } catch (std::out_of_range& e) {
24838       {
24839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24840       };
24841     } catch (std::exception& e) {
24842       {
24843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24844       };
24845     } catch (Dali::DaliException e) {
24846       {
24847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24848       };
24849     } catch (...) {
24850       {
24851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24852       };
24853     }
24854   }
24855
24856   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24857   return jresult;
24858 }
24859
24860
24861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24862   void * jresult ;
24863   Dali::TextureSet *result = 0 ;
24864
24865   {
24866     try {
24867       result = (Dali::TextureSet *)new Dali::TextureSet();
24868     } catch (std::out_of_range& e) {
24869       {
24870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24871       };
24872     } catch (std::exception& e) {
24873       {
24874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24875       };
24876     } catch (Dali::DaliException e) {
24877       {
24878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24879       };
24880     } catch (...) {
24881       {
24882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24883       };
24884     }
24885   }
24886
24887   jresult = (void *)result;
24888   return jresult;
24889 }
24890
24891
24892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24893   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24894
24895   arg1 = (Dali::TextureSet *)jarg1;
24896   {
24897     try {
24898       delete arg1;
24899     } catch (std::out_of_range& e) {
24900       {
24901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24902       };
24903     } catch (std::exception& e) {
24904       {
24905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24906       };
24907     } catch (Dali::DaliException e) {
24908       {
24909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24910       };
24911     } catch (...) {
24912       {
24913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24914       };
24915     }
24916   }
24917
24918 }
24919
24920
24921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24922   void * jresult ;
24923   Dali::TextureSet *arg1 = 0 ;
24924   Dali::TextureSet *result = 0 ;
24925
24926   arg1 = (Dali::TextureSet *)jarg1;
24927   if (!arg1) {
24928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24929     return 0;
24930   }
24931   {
24932     try {
24933       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24934     } catch (std::out_of_range& e) {
24935       {
24936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24937       };
24938     } catch (std::exception& e) {
24939       {
24940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24941       };
24942     } catch (Dali::DaliException e) {
24943       {
24944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24945       };
24946     } catch (...) {
24947       {
24948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24949       };
24950     }
24951   }
24952
24953   jresult = (void *)result;
24954   return jresult;
24955 }
24956
24957
24958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24959   void * jresult ;
24960   Dali::BaseHandle arg1 ;
24961   Dali::BaseHandle *argp1 ;
24962   Dali::TextureSet result;
24963
24964   argp1 = (Dali::BaseHandle *)jarg1;
24965   if (!argp1) {
24966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24967     return 0;
24968   }
24969   arg1 = *argp1;
24970   {
24971     try {
24972       result = Dali::TextureSet::DownCast(arg1);
24973     } catch (std::out_of_range& e) {
24974       {
24975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24976       };
24977     } catch (std::exception& e) {
24978       {
24979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24980       };
24981     } catch (Dali::DaliException e) {
24982       {
24983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24984       };
24985     } catch (...) {
24986       {
24987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24988       };
24989     }
24990   }
24991
24992   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24993   return jresult;
24994 }
24995
24996
24997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24998   void * jresult ;
24999   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25000   Dali::TextureSet *arg2 = 0 ;
25001   Dali::TextureSet *result = 0 ;
25002
25003   arg1 = (Dali::TextureSet *)jarg1;
25004   arg2 = (Dali::TextureSet *)jarg2;
25005   if (!arg2) {
25006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25007     return 0;
25008   }
25009   {
25010     try {
25011       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25012     } catch (std::out_of_range& e) {
25013       {
25014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25015       };
25016     } catch (std::exception& e) {
25017       {
25018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25019       };
25020     } catch (Dali::DaliException e) {
25021       {
25022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25023       };
25024     } catch (...) {
25025       {
25026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25027       };
25028     }
25029   }
25030
25031   jresult = (void *)result;
25032   return jresult;
25033 }
25034
25035
25036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25037   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25038   size_t arg2 ;
25039   Dali::Texture arg3 ;
25040   Dali::Texture *argp3 ;
25041
25042   arg1 = (Dali::TextureSet *)jarg1;
25043   arg2 = (size_t)jarg2;
25044   argp3 = (Dali::Texture *)jarg3;
25045   if (!argp3) {
25046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25047     return ;
25048   }
25049   arg3 = *argp3;
25050   {
25051     try {
25052       (arg1)->SetTexture(arg2,arg3);
25053     } catch (std::out_of_range& e) {
25054       {
25055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25056       };
25057     } catch (std::exception& e) {
25058       {
25059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25060       };
25061     } catch (Dali::DaliException e) {
25062       {
25063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25064       };
25065     } catch (...) {
25066       {
25067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25068       };
25069     }
25070   }
25071
25072 }
25073
25074
25075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25076   void * jresult ;
25077   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25078   size_t arg2 ;
25079   Dali::Texture result;
25080
25081   arg1 = (Dali::TextureSet *)jarg1;
25082   arg2 = (size_t)jarg2;
25083   {
25084     try {
25085       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25086     } catch (std::out_of_range& e) {
25087       {
25088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25089       };
25090     } catch (std::exception& e) {
25091       {
25092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25093       };
25094     } catch (Dali::DaliException e) {
25095       {
25096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25097       };
25098     } catch (...) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25101       };
25102     }
25103   }
25104
25105   jresult = new Dali::Texture((const Dali::Texture &)result);
25106   return jresult;
25107 }
25108
25109
25110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25111   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25112   size_t arg2 ;
25113   Dali::Sampler arg3 ;
25114   Dali::Sampler *argp3 ;
25115
25116   arg1 = (Dali::TextureSet *)jarg1;
25117   arg2 = (size_t)jarg2;
25118   argp3 = (Dali::Sampler *)jarg3;
25119   if (!argp3) {
25120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25121     return ;
25122   }
25123   arg3 = *argp3;
25124   {
25125     try {
25126       (arg1)->SetSampler(arg2,arg3);
25127     } catch (std::out_of_range& e) {
25128       {
25129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25130       };
25131     } catch (std::exception& e) {
25132       {
25133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25134       };
25135     } catch (Dali::DaliException e) {
25136       {
25137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25138       };
25139     } catch (...) {
25140       {
25141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25142       };
25143     }
25144   }
25145
25146 }
25147
25148
25149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25150   void * jresult ;
25151   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25152   size_t arg2 ;
25153   Dali::Sampler result;
25154
25155   arg1 = (Dali::TextureSet *)jarg1;
25156   arg2 = (size_t)jarg2;
25157   {
25158     try {
25159       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25160     } catch (std::out_of_range& e) {
25161       {
25162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25163       };
25164     } catch (std::exception& e) {
25165       {
25166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25167       };
25168     } catch (Dali::DaliException e) {
25169       {
25170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25171       };
25172     } catch (...) {
25173       {
25174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25175       };
25176     }
25177   }
25178
25179   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25180   return jresult;
25181 }
25182
25183
25184 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25185   unsigned long jresult ;
25186   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25187   size_t result;
25188
25189   arg1 = (Dali::TextureSet *)jarg1;
25190   {
25191     try {
25192       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25193     } catch (std::out_of_range& e) {
25194       {
25195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25196       };
25197     } catch (std::exception& e) {
25198       {
25199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25200       };
25201     } catch (Dali::DaliException e) {
25202       {
25203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25204       };
25205     } catch (...) {
25206       {
25207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25208       };
25209     }
25210   }
25211
25212   jresult = (unsigned long)result;
25213   return jresult;
25214 }
25215
25216
25217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25218   void * jresult ;
25219   Dali::Property::Map *arg1 = 0 ;
25220   Dali::PropertyBuffer result;
25221
25222   arg1 = (Dali::Property::Map *)jarg1;
25223   if (!arg1) {
25224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25225     return 0;
25226   }
25227   {
25228     try {
25229       result = Dali::PropertyBuffer::New(*arg1);
25230     } catch (std::out_of_range& e) {
25231       {
25232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25233       };
25234     } catch (std::exception& e) {
25235       {
25236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25237       };
25238     } catch (Dali::DaliException e) {
25239       {
25240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25241       };
25242     } catch (...) {
25243       {
25244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25245       };
25246     }
25247   }
25248
25249   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25250   return jresult;
25251 }
25252
25253
25254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25255   void * jresult ;
25256   Dali::PropertyBuffer *result = 0 ;
25257
25258   {
25259     try {
25260       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25261     } catch (std::out_of_range& e) {
25262       {
25263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25264       };
25265     } catch (std::exception& e) {
25266       {
25267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25268       };
25269     } catch (Dali::DaliException e) {
25270       {
25271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25272       };
25273     } catch (...) {
25274       {
25275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25276       };
25277     }
25278   }
25279
25280   jresult = (void *)result;
25281   return jresult;
25282 }
25283
25284
25285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25286   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25287
25288   arg1 = (Dali::PropertyBuffer *)jarg1;
25289   {
25290     try {
25291       delete arg1;
25292     } catch (std::out_of_range& e) {
25293       {
25294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25295       };
25296     } catch (std::exception& e) {
25297       {
25298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25299       };
25300     } catch (Dali::DaliException e) {
25301       {
25302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25303       };
25304     } catch (...) {
25305       {
25306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25307       };
25308     }
25309   }
25310
25311 }
25312
25313
25314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25315   void * jresult ;
25316   Dali::PropertyBuffer *arg1 = 0 ;
25317   Dali::PropertyBuffer *result = 0 ;
25318
25319   arg1 = (Dali::PropertyBuffer *)jarg1;
25320   if (!arg1) {
25321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25322     return 0;
25323   }
25324   {
25325     try {
25326       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25327     } catch (std::out_of_range& e) {
25328       {
25329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25330       };
25331     } catch (std::exception& e) {
25332       {
25333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25334       };
25335     } catch (Dali::DaliException e) {
25336       {
25337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25338       };
25339     } catch (...) {
25340       {
25341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25342       };
25343     }
25344   }
25345
25346   jresult = (void *)result;
25347   return jresult;
25348 }
25349
25350
25351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25352   void * jresult ;
25353   Dali::BaseHandle arg1 ;
25354   Dali::BaseHandle *argp1 ;
25355   Dali::PropertyBuffer result;
25356
25357   argp1 = (Dali::BaseHandle *)jarg1;
25358   if (!argp1) {
25359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25360     return 0;
25361   }
25362   arg1 = *argp1;
25363   {
25364     try {
25365       result = Dali::PropertyBuffer::DownCast(arg1);
25366     } catch (std::out_of_range& e) {
25367       {
25368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25369       };
25370     } catch (std::exception& e) {
25371       {
25372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25373       };
25374     } catch (Dali::DaliException e) {
25375       {
25376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25377       };
25378     } catch (...) {
25379       {
25380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25381       };
25382     }
25383   }
25384
25385   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25386   return jresult;
25387 }
25388
25389
25390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25391   void * jresult ;
25392   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25393   Dali::PropertyBuffer *arg2 = 0 ;
25394   Dali::PropertyBuffer *result = 0 ;
25395
25396   arg1 = (Dali::PropertyBuffer *)jarg1;
25397   arg2 = (Dali::PropertyBuffer *)jarg2;
25398   if (!arg2) {
25399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25400     return 0;
25401   }
25402   {
25403     try {
25404       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25405     } catch (std::out_of_range& e) {
25406       {
25407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25408       };
25409     } catch (std::exception& e) {
25410       {
25411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25412       };
25413     } catch (Dali::DaliException e) {
25414       {
25415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25416       };
25417     } catch (...) {
25418       {
25419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25420       };
25421     }
25422   }
25423
25424   jresult = (void *)result;
25425   return jresult;
25426 }
25427
25428
25429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25430   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25431   void *arg2 = (void *) 0 ;
25432   std::size_t arg3 ;
25433
25434   arg1 = (Dali::PropertyBuffer *)jarg1;
25435   arg2 = jarg2;
25436   arg3 = (std::size_t)jarg3;
25437   {
25438     try {
25439       (arg1)->SetData((void const *)arg2,arg3);
25440     } catch (std::out_of_range& e) {
25441       {
25442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25443       };
25444     } catch (std::exception& e) {
25445       {
25446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25447       };
25448     } catch (Dali::DaliException e) {
25449       {
25450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25451       };
25452     } catch (...) {
25453       {
25454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25455       };
25456     }
25457   }
25458
25459 }
25460
25461
25462 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25463   unsigned long jresult ;
25464   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25465   std::size_t result;
25466
25467   arg1 = (Dali::PropertyBuffer *)jarg1;
25468   {
25469     try {
25470       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25471     } catch (std::out_of_range& e) {
25472       {
25473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25474       };
25475     } catch (std::exception& e) {
25476       {
25477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25478       };
25479     } catch (Dali::DaliException e) {
25480       {
25481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25482       };
25483     } catch (...) {
25484       {
25485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25486       };
25487     }
25488   }
25489
25490   jresult = (unsigned long)result;
25491   return jresult;
25492 }
25493
25494
25495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25496   void * jresult ;
25497   Dali::Geometry result;
25498
25499   {
25500     try {
25501       result = Dali::Geometry::New();
25502     } catch (std::out_of_range& e) {
25503       {
25504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25505       };
25506     } catch (std::exception& e) {
25507       {
25508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25509       };
25510     } catch (Dali::DaliException e) {
25511       {
25512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25513       };
25514     } catch (...) {
25515       {
25516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25517       };
25518     }
25519   }
25520
25521   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25522   return jresult;
25523 }
25524
25525
25526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25527   void * jresult ;
25528   Dali::Geometry *result = 0 ;
25529
25530   {
25531     try {
25532       result = (Dali::Geometry *)new Dali::Geometry();
25533     } catch (std::out_of_range& e) {
25534       {
25535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25536       };
25537     } catch (std::exception& e) {
25538       {
25539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25540       };
25541     } catch (Dali::DaliException e) {
25542       {
25543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25544       };
25545     } catch (...) {
25546       {
25547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25548       };
25549     }
25550   }
25551
25552   jresult = (void *)result;
25553   return jresult;
25554 }
25555
25556
25557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25558   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25559
25560   arg1 = (Dali::Geometry *)jarg1;
25561   {
25562     try {
25563       delete arg1;
25564     } catch (std::out_of_range& e) {
25565       {
25566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25567       };
25568     } catch (std::exception& e) {
25569       {
25570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25571       };
25572     } catch (Dali::DaliException e) {
25573       {
25574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25575       };
25576     } catch (...) {
25577       {
25578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25579       };
25580     }
25581   }
25582
25583 }
25584
25585
25586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25587   void * jresult ;
25588   Dali::Geometry *arg1 = 0 ;
25589   Dali::Geometry *result = 0 ;
25590
25591   arg1 = (Dali::Geometry *)jarg1;
25592   if (!arg1) {
25593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25594     return 0;
25595   }
25596   {
25597     try {
25598       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25599     } catch (std::out_of_range& e) {
25600       {
25601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25602       };
25603     } catch (std::exception& e) {
25604       {
25605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25606       };
25607     } catch (Dali::DaliException e) {
25608       {
25609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25610       };
25611     } catch (...) {
25612       {
25613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25614       };
25615     }
25616   }
25617
25618   jresult = (void *)result;
25619   return jresult;
25620 }
25621
25622
25623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25624   void * jresult ;
25625   Dali::BaseHandle arg1 ;
25626   Dali::BaseHandle *argp1 ;
25627   Dali::Geometry result;
25628
25629   argp1 = (Dali::BaseHandle *)jarg1;
25630   if (!argp1) {
25631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25632     return 0;
25633   }
25634   arg1 = *argp1;
25635   {
25636     try {
25637       result = Dali::Geometry::DownCast(arg1);
25638     } catch (std::out_of_range& e) {
25639       {
25640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25641       };
25642     } catch (std::exception& e) {
25643       {
25644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25645       };
25646     } catch (Dali::DaliException e) {
25647       {
25648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25649       };
25650     } catch (...) {
25651       {
25652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25653       };
25654     }
25655   }
25656
25657   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25658   return jresult;
25659 }
25660
25661
25662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25663   void * jresult ;
25664   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25665   Dali::Geometry *arg2 = 0 ;
25666   Dali::Geometry *result = 0 ;
25667
25668   arg1 = (Dali::Geometry *)jarg1;
25669   arg2 = (Dali::Geometry *)jarg2;
25670   if (!arg2) {
25671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25672     return 0;
25673   }
25674   {
25675     try {
25676       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25677     } catch (std::out_of_range& e) {
25678       {
25679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25680       };
25681     } catch (std::exception& e) {
25682       {
25683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25684       };
25685     } catch (Dali::DaliException e) {
25686       {
25687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25688       };
25689     } catch (...) {
25690       {
25691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25692       };
25693     }
25694   }
25695
25696   jresult = (void *)result;
25697   return jresult;
25698 }
25699
25700
25701 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25702   unsigned long jresult ;
25703   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25704   Dali::PropertyBuffer *arg2 = 0 ;
25705   std::size_t result;
25706
25707   arg1 = (Dali::Geometry *)jarg1;
25708   arg2 = (Dali::PropertyBuffer *)jarg2;
25709   if (!arg2) {
25710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25711     return 0;
25712   }
25713   {
25714     try {
25715       result = (arg1)->AddVertexBuffer(*arg2);
25716     } catch (std::out_of_range& e) {
25717       {
25718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25719       };
25720     } catch (std::exception& e) {
25721       {
25722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25723       };
25724     } catch (Dali::DaliException e) {
25725       {
25726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25727       };
25728     } catch (...) {
25729       {
25730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25731       };
25732     }
25733   }
25734
25735   jresult = (unsigned long)result;
25736   return jresult;
25737 }
25738
25739
25740 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25741   unsigned long jresult ;
25742   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25743   std::size_t result;
25744
25745   arg1 = (Dali::Geometry *)jarg1;
25746   {
25747     try {
25748       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25749     } catch (std::out_of_range& e) {
25750       {
25751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25752       };
25753     } catch (std::exception& e) {
25754       {
25755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25756       };
25757     } catch (Dali::DaliException e) {
25758       {
25759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25760       };
25761     } catch (...) {
25762       {
25763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25764       };
25765     }
25766   }
25767
25768   jresult = (unsigned long)result;
25769   return jresult;
25770 }
25771
25772
25773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25774   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25775   std::size_t arg2 ;
25776
25777   arg1 = (Dali::Geometry *)jarg1;
25778   arg2 = (std::size_t)jarg2;
25779   {
25780     try {
25781       (arg1)->RemoveVertexBuffer(arg2);
25782     } catch (std::out_of_range& e) {
25783       {
25784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25785       };
25786     } catch (std::exception& e) {
25787       {
25788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25789       };
25790     } catch (Dali::DaliException e) {
25791       {
25792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25793       };
25794     } catch (...) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25797       };
25798     }
25799   }
25800
25801 }
25802
25803
25804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25805   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25806   unsigned short *arg2 = (unsigned short *) 0 ;
25807   size_t arg3 ;
25808
25809   arg1 = (Dali::Geometry *)jarg1;
25810   arg2 = jarg2;
25811   arg3 = (size_t)jarg3;
25812   {
25813     try {
25814       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25815     } catch (std::out_of_range& e) {
25816       {
25817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25818       };
25819     } catch (std::exception& e) {
25820       {
25821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25822       };
25823     } catch (Dali::DaliException e) {
25824       {
25825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25826       };
25827     } catch (...) {
25828       {
25829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25830       };
25831     }
25832   }
25833
25834
25835
25836 }
25837
25838
25839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25840   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25841   Dali::Geometry::Type arg2 ;
25842
25843   arg1 = (Dali::Geometry *)jarg1;
25844   arg2 = (Dali::Geometry::Type)jarg2;
25845   {
25846     try {
25847       (arg1)->SetType(arg2);
25848     } catch (std::out_of_range& e) {
25849       {
25850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25851       };
25852     } catch (std::exception& e) {
25853       {
25854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25855       };
25856     } catch (Dali::DaliException e) {
25857       {
25858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25859       };
25860     } catch (...) {
25861       {
25862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25863       };
25864     }
25865   }
25866
25867 }
25868
25869
25870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25871   int jresult ;
25872   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25873   Dali::Geometry::Type result;
25874
25875   arg1 = (Dali::Geometry *)jarg1;
25876   {
25877     try {
25878       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25879     } catch (std::out_of_range& e) {
25880       {
25881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25882       };
25883     } catch (std::exception& e) {
25884       {
25885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25886       };
25887     } catch (Dali::DaliException e) {
25888       {
25889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25890       };
25891     } catch (...) {
25892       {
25893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25894       };
25895     }
25896   }
25897
25898   jresult = (int)result;
25899   return jresult;
25900 }
25901
25902
25903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25904   void * jresult ;
25905   Dali::Shader::Hint *result = 0 ;
25906
25907   {
25908     try {
25909       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25910     } catch (std::out_of_range& e) {
25911       {
25912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25913       };
25914     } catch (std::exception& e) {
25915       {
25916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25917       };
25918     } catch (Dali::DaliException e) {
25919       {
25920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25921       };
25922     } catch (...) {
25923       {
25924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25925       };
25926     }
25927   }
25928
25929   jresult = (void *)result;
25930   return jresult;
25931 }
25932
25933
25934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25935   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25936
25937   arg1 = (Dali::Shader::Hint *)jarg1;
25938   {
25939     try {
25940       delete arg1;
25941     } catch (std::out_of_range& e) {
25942       {
25943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25944       };
25945     } catch (std::exception& e) {
25946       {
25947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25948       };
25949     } catch (Dali::DaliException e) {
25950       {
25951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25952       };
25953     } catch (...) {
25954       {
25955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25956       };
25957     }
25958   }
25959
25960 }
25961
25962
25963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25964   int jresult ;
25965   int result;
25966
25967   result = (int)Dali::Shader::Property::PROGRAM;
25968   jresult = (int)result;
25969   return jresult;
25970 }
25971
25972
25973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25974   void * jresult ;
25975   Dali::Shader::Property *result = 0 ;
25976
25977   {
25978     try {
25979       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25980     } catch (std::out_of_range& e) {
25981       {
25982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25983       };
25984     } catch (std::exception& e) {
25985       {
25986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25987       };
25988     } catch (Dali::DaliException e) {
25989       {
25990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25991       };
25992     } catch (...) {
25993       {
25994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25995       };
25996     }
25997   }
25998
25999   jresult = (void *)result;
26000   return jresult;
26001 }
26002
26003
26004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26005   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26006
26007   arg1 = (Dali::Shader::Property *)jarg1;
26008   {
26009     try {
26010       delete arg1;
26011     } catch (std::out_of_range& e) {
26012       {
26013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26014       };
26015     } catch (std::exception& e) {
26016       {
26017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26018       };
26019     } catch (Dali::DaliException e) {
26020       {
26021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26022       };
26023     } catch (...) {
26024       {
26025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26026       };
26027     }
26028   }
26029
26030 }
26031
26032
26033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26034   void * jresult ;
26035   std::string *arg1 = 0 ;
26036   std::string *arg2 = 0 ;
26037   Dali::Shader::Hint::Value arg3 ;
26038   Dali::Shader result;
26039
26040   if (!jarg1) {
26041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26042     return 0;
26043   }
26044   std::string arg1_str(jarg1);
26045   arg1 = &arg1_str;
26046   if (!jarg2) {
26047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26048     return 0;
26049   }
26050   std::string arg2_str(jarg2);
26051   arg2 = &arg2_str;
26052   arg3 = (Dali::Shader::Hint::Value)jarg3;
26053   {
26054     try {
26055       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26056     } catch (std::out_of_range& e) {
26057       {
26058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26059       };
26060     } catch (std::exception& e) {
26061       {
26062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26063       };
26064     } catch (Dali::DaliException e) {
26065       {
26066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26067       };
26068     } catch (...) {
26069       {
26070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26071       };
26072     }
26073   }
26074
26075   jresult = new Dali::Shader((const Dali::Shader &)result);
26076
26077   //argout typemap for const std::string&
26078
26079
26080   //argout typemap for const std::string&
26081
26082   return jresult;
26083 }
26084
26085
26086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26087   void * jresult ;
26088   std::string *arg1 = 0 ;
26089   std::string *arg2 = 0 ;
26090   Dali::Shader result;
26091
26092   if (!jarg1) {
26093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26094     return 0;
26095   }
26096   std::string arg1_str(jarg1);
26097   arg1 = &arg1_str;
26098   if (!jarg2) {
26099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26100     return 0;
26101   }
26102   std::string arg2_str(jarg2);
26103   arg2 = &arg2_str;
26104   {
26105     try {
26106       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26107     } catch (std::out_of_range& e) {
26108       {
26109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26110       };
26111     } catch (std::exception& e) {
26112       {
26113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26114       };
26115     } catch (Dali::DaliException e) {
26116       {
26117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26118       };
26119     } catch (...) {
26120       {
26121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26122       };
26123     }
26124   }
26125
26126   jresult = new Dali::Shader((const Dali::Shader &)result);
26127
26128   //argout typemap for const std::string&
26129
26130
26131   //argout typemap for const std::string&
26132
26133   return jresult;
26134 }
26135
26136
26137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26138   void * jresult ;
26139   Dali::Shader *result = 0 ;
26140
26141   {
26142     try {
26143       result = (Dali::Shader *)new Dali::Shader();
26144     } catch (std::out_of_range& e) {
26145       {
26146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26147       };
26148     } catch (std::exception& e) {
26149       {
26150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26151       };
26152     } catch (Dali::DaliException e) {
26153       {
26154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26155       };
26156     } catch (...) {
26157       {
26158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26159       };
26160     }
26161   }
26162
26163   jresult = (void *)result;
26164   return jresult;
26165 }
26166
26167
26168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26169   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26170
26171   arg1 = (Dali::Shader *)jarg1;
26172   {
26173     try {
26174       delete arg1;
26175     } catch (std::out_of_range& e) {
26176       {
26177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26178       };
26179     } catch (std::exception& e) {
26180       {
26181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26182       };
26183     } catch (Dali::DaliException e) {
26184       {
26185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26186       };
26187     } catch (...) {
26188       {
26189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26190       };
26191     }
26192   }
26193
26194 }
26195
26196
26197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26198   void * jresult ;
26199   Dali::Shader *arg1 = 0 ;
26200   Dali::Shader *result = 0 ;
26201
26202   arg1 = (Dali::Shader *)jarg1;
26203   if (!arg1) {
26204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26205     return 0;
26206   }
26207   {
26208     try {
26209       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26210     } catch (std::out_of_range& e) {
26211       {
26212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26213       };
26214     } catch (std::exception& e) {
26215       {
26216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26217       };
26218     } catch (Dali::DaliException e) {
26219       {
26220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26221       };
26222     } catch (...) {
26223       {
26224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26225       };
26226     }
26227   }
26228
26229   jresult = (void *)result;
26230   return jresult;
26231 }
26232
26233
26234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26235   void * jresult ;
26236   Dali::BaseHandle arg1 ;
26237   Dali::BaseHandle *argp1 ;
26238   Dali::Shader result;
26239
26240   argp1 = (Dali::BaseHandle *)jarg1;
26241   if (!argp1) {
26242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26243     return 0;
26244   }
26245   arg1 = *argp1;
26246   {
26247     try {
26248       result = Dali::Shader::DownCast(arg1);
26249     } catch (std::out_of_range& e) {
26250       {
26251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26252       };
26253     } catch (std::exception& e) {
26254       {
26255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26256       };
26257     } catch (Dali::DaliException e) {
26258       {
26259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26260       };
26261     } catch (...) {
26262       {
26263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26264       };
26265     }
26266   }
26267
26268   jresult = new Dali::Shader((const Dali::Shader &)result);
26269   return jresult;
26270 }
26271
26272
26273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26274   void * jresult ;
26275   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26276   Dali::Shader *arg2 = 0 ;
26277   Dali::Shader *result = 0 ;
26278
26279   arg1 = (Dali::Shader *)jarg1;
26280   arg2 = (Dali::Shader *)jarg2;
26281   if (!arg2) {
26282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26283     return 0;
26284   }
26285   {
26286     try {
26287       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26288     } catch (std::out_of_range& e) {
26289       {
26290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26291       };
26292     } catch (std::exception& e) {
26293       {
26294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26295       };
26296     } catch (Dali::DaliException e) {
26297       {
26298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26299       };
26300     } catch (...) {
26301       {
26302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26303       };
26304     }
26305   }
26306
26307   jresult = (void *)result;
26308   return jresult;
26309 }
26310
26311
26312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26313   int jresult ;
26314   int result;
26315
26316   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26317   jresult = (int)result;
26318   return jresult;
26319 }
26320
26321
26322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26323   int jresult ;
26324   int result;
26325
26326   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26327   jresult = (int)result;
26328   return jresult;
26329 }
26330
26331
26332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26333   int jresult ;
26334   int result;
26335
26336   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26337   jresult = (int)result;
26338   return jresult;
26339 }
26340
26341
26342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26343   int jresult ;
26344   int result;
26345
26346   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26347   jresult = (int)result;
26348   return jresult;
26349 }
26350
26351
26352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26353   int jresult ;
26354   int result;
26355
26356   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26357   jresult = (int)result;
26358   return jresult;
26359 }
26360
26361
26362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26363   int jresult ;
26364   int result;
26365
26366   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26367   jresult = (int)result;
26368   return jresult;
26369 }
26370
26371
26372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26373   int jresult ;
26374   int result;
26375
26376   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26377   jresult = (int)result;
26378   return jresult;
26379 }
26380
26381
26382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26383   int jresult ;
26384   int result;
26385
26386   result = (int)Dali::Renderer::Property::BLEND_MODE;
26387   jresult = (int)result;
26388   return jresult;
26389 }
26390
26391
26392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26393   int jresult ;
26394   int result;
26395
26396   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26397   jresult = (int)result;
26398   return jresult;
26399 }
26400
26401
26402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26403   int jresult ;
26404   int result;
26405
26406   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26407   jresult = (int)result;
26408   return jresult;
26409 }
26410
26411
26412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26413   int jresult ;
26414   int result;
26415
26416   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26417   jresult = (int)result;
26418   return jresult;
26419 }
26420
26421
26422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26423   int jresult ;
26424   int result;
26425
26426   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26427   jresult = (int)result;
26428   return jresult;
26429 }
26430
26431
26432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26433   int jresult ;
26434   int result;
26435
26436   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26437   jresult = (int)result;
26438   return jresult;
26439 }
26440
26441
26442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26443   int jresult ;
26444   int result;
26445
26446   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26447   jresult = (int)result;
26448   return jresult;
26449 }
26450
26451
26452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26453   int jresult ;
26454   int result;
26455
26456   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26457   jresult = (int)result;
26458   return jresult;
26459 }
26460
26461
26462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26463   int jresult ;
26464   int result;
26465
26466   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26467   jresult = (int)result;
26468   return jresult;
26469 }
26470
26471
26472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26473   int jresult ;
26474   int result;
26475
26476   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26477   jresult = (int)result;
26478   return jresult;
26479 }
26480
26481
26482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26483   int jresult ;
26484   int result;
26485
26486   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26487   jresult = (int)result;
26488   return jresult;
26489 }
26490
26491
26492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26493   int jresult ;
26494   int result;
26495
26496   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26497   jresult = (int)result;
26498   return jresult;
26499 }
26500
26501
26502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26503   int jresult ;
26504   int result;
26505
26506   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26507   jresult = (int)result;
26508   return jresult;
26509 }
26510
26511
26512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26513   int jresult ;
26514   int result;
26515
26516   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26517   jresult = (int)result;
26518   return jresult;
26519 }
26520
26521
26522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26523   int jresult ;
26524   int result;
26525
26526   result = (int)Dali::Renderer::Property::RENDER_MODE;
26527   jresult = (int)result;
26528   return jresult;
26529 }
26530
26531
26532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26533   int jresult ;
26534   int result;
26535
26536   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26537   jresult = (int)result;
26538   return jresult;
26539 }
26540
26541
26542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26543   int jresult ;
26544   int result;
26545
26546   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26547   jresult = (int)result;
26548   return jresult;
26549 }
26550
26551
26552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26553   int jresult ;
26554   int result;
26555
26556   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26557   jresult = (int)result;
26558   return jresult;
26559 }
26560
26561
26562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26563   int jresult ;
26564   int result;
26565
26566   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26567   jresult = (int)result;
26568   return jresult;
26569 }
26570
26571
26572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26573   int jresult ;
26574   int result;
26575
26576   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26577   jresult = (int)result;
26578   return jresult;
26579 }
26580
26581
26582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26583   int jresult ;
26584   int result;
26585
26586   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26587   jresult = (int)result;
26588   return jresult;
26589 }
26590
26591
26592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26593   int jresult ;
26594   int result;
26595
26596   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26597   jresult = (int)result;
26598   return jresult;
26599 }
26600
26601
26602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26603   void * jresult ;
26604   Dali::Renderer::Property *result = 0 ;
26605
26606   {
26607     try {
26608       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26609     } catch (std::out_of_range& e) {
26610       {
26611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26612       };
26613     } catch (std::exception& e) {
26614       {
26615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26616       };
26617     } catch (Dali::DaliException e) {
26618       {
26619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26620       };
26621     } catch (...) {
26622       {
26623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26624       };
26625     }
26626   }
26627
26628   jresult = (void *)result;
26629   return jresult;
26630 }
26631
26632
26633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26634   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26635
26636   arg1 = (Dali::Renderer::Property *)jarg1;
26637   {
26638     try {
26639       delete arg1;
26640     } catch (std::out_of_range& e) {
26641       {
26642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26643       };
26644     } catch (std::exception& e) {
26645       {
26646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26647       };
26648     } catch (Dali::DaliException e) {
26649       {
26650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26651       };
26652     } catch (...) {
26653       {
26654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26655       };
26656     }
26657   }
26658
26659 }
26660
26661
26662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26663   void * jresult ;
26664   Dali::Geometry *arg1 = 0 ;
26665   Dali::Shader *arg2 = 0 ;
26666   Dali::Renderer result;
26667
26668   arg1 = (Dali::Geometry *)jarg1;
26669   if (!arg1) {
26670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26671     return 0;
26672   }
26673   arg2 = (Dali::Shader *)jarg2;
26674   if (!arg2) {
26675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26676     return 0;
26677   }
26678   {
26679     try {
26680       result = Dali::Renderer::New(*arg1,*arg2);
26681     } catch (std::out_of_range& e) {
26682       {
26683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26684       };
26685     } catch (std::exception& e) {
26686       {
26687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26688       };
26689     } catch (Dali::DaliException e) {
26690       {
26691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26692       };
26693     } catch (...) {
26694       {
26695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26696       };
26697     }
26698   }
26699
26700   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26701   return jresult;
26702 }
26703
26704
26705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26706   void * jresult ;
26707   Dali::Renderer *result = 0 ;
26708
26709   {
26710     try {
26711       result = (Dali::Renderer *)new Dali::Renderer();
26712     } catch (std::out_of_range& e) {
26713       {
26714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26715       };
26716     } catch (std::exception& e) {
26717       {
26718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26719       };
26720     } catch (Dali::DaliException e) {
26721       {
26722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26723       };
26724     } catch (...) {
26725       {
26726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26727       };
26728     }
26729   }
26730
26731   jresult = (void *)result;
26732   return jresult;
26733 }
26734
26735
26736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26737   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26738
26739   arg1 = (Dali::Renderer *)jarg1;
26740   {
26741     try {
26742       delete arg1;
26743     } catch (std::out_of_range& e) {
26744       {
26745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26746       };
26747     } catch (std::exception& e) {
26748       {
26749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26750       };
26751     } catch (Dali::DaliException e) {
26752       {
26753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26754       };
26755     } catch (...) {
26756       {
26757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26758       };
26759     }
26760   }
26761
26762 }
26763
26764
26765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26766   void * jresult ;
26767   Dali::Renderer *arg1 = 0 ;
26768   Dali::Renderer *result = 0 ;
26769
26770   arg1 = (Dali::Renderer *)jarg1;
26771   if (!arg1) {
26772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26773     return 0;
26774   }
26775   {
26776     try {
26777       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26778     } catch (std::out_of_range& e) {
26779       {
26780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26781       };
26782     } catch (std::exception& e) {
26783       {
26784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26785       };
26786     } catch (Dali::DaliException e) {
26787       {
26788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26789       };
26790     } catch (...) {
26791       {
26792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26793       };
26794     }
26795   }
26796
26797   jresult = (void *)result;
26798   return jresult;
26799 }
26800
26801
26802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26803   void * jresult ;
26804   Dali::BaseHandle arg1 ;
26805   Dali::BaseHandle *argp1 ;
26806   Dali::Renderer result;
26807
26808   argp1 = (Dali::BaseHandle *)jarg1;
26809   if (!argp1) {
26810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26811     return 0;
26812   }
26813   arg1 = *argp1;
26814   {
26815     try {
26816       result = Dali::Renderer::DownCast(arg1);
26817     } catch (std::out_of_range& e) {
26818       {
26819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26820       };
26821     } catch (std::exception& e) {
26822       {
26823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26824       };
26825     } catch (Dali::DaliException e) {
26826       {
26827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26828       };
26829     } catch (...) {
26830       {
26831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26832       };
26833     }
26834   }
26835
26836   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26837   return jresult;
26838 }
26839
26840
26841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26842   void * jresult ;
26843   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26844   Dali::Renderer *arg2 = 0 ;
26845   Dali::Renderer *result = 0 ;
26846
26847   arg1 = (Dali::Renderer *)jarg1;
26848   arg2 = (Dali::Renderer *)jarg2;
26849   if (!arg2) {
26850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26851     return 0;
26852   }
26853   {
26854     try {
26855       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26856     } catch (std::out_of_range& e) {
26857       {
26858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26859       };
26860     } catch (std::exception& e) {
26861       {
26862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26863       };
26864     } catch (Dali::DaliException e) {
26865       {
26866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26867       };
26868     } catch (...) {
26869       {
26870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26871       };
26872     }
26873   }
26874
26875   jresult = (void *)result;
26876   return jresult;
26877 }
26878
26879
26880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26881   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26882   Dali::Geometry *arg2 = 0 ;
26883
26884   arg1 = (Dali::Renderer *)jarg1;
26885   arg2 = (Dali::Geometry *)jarg2;
26886   if (!arg2) {
26887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26888     return ;
26889   }
26890   {
26891     try {
26892       (arg1)->SetGeometry(*arg2);
26893     } catch (std::out_of_range& e) {
26894       {
26895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26896       };
26897     } catch (std::exception& e) {
26898       {
26899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26900       };
26901     } catch (Dali::DaliException e) {
26902       {
26903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26904       };
26905     } catch (...) {
26906       {
26907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26908       };
26909     }
26910   }
26911
26912 }
26913
26914
26915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26916   void * jresult ;
26917   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26918   Dali::Geometry result;
26919
26920   arg1 = (Dali::Renderer *)jarg1;
26921   {
26922     try {
26923       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26924     } catch (std::out_of_range& e) {
26925       {
26926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26927       };
26928     } catch (std::exception& e) {
26929       {
26930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26931       };
26932     } catch (Dali::DaliException e) {
26933       {
26934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26935       };
26936     } catch (...) {
26937       {
26938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26939       };
26940     }
26941   }
26942
26943   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26944   return jresult;
26945 }
26946
26947
26948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26949   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26950   int arg2 ;
26951   int arg3 ;
26952
26953   arg1 = (Dali::Renderer *)jarg1;
26954   arg2 = (int)jarg2;
26955   arg3 = (int)jarg3;
26956   {
26957     try {
26958       (arg1)->SetIndexRange(arg2,arg3);
26959     } catch (std::out_of_range& e) {
26960       {
26961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26962       };
26963     } catch (std::exception& e) {
26964       {
26965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26966       };
26967     } catch (Dali::DaliException e) {
26968       {
26969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26970       };
26971     } catch (...) {
26972       {
26973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26974       };
26975     }
26976   }
26977
26978 }
26979
26980
26981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26982   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26983   Dali::TextureSet *arg2 = 0 ;
26984
26985   arg1 = (Dali::Renderer *)jarg1;
26986   arg2 = (Dali::TextureSet *)jarg2;
26987   if (!arg2) {
26988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26989     return ;
26990   }
26991   {
26992     try {
26993       (arg1)->SetTextures(*arg2);
26994     } catch (std::out_of_range& e) {
26995       {
26996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26997       };
26998     } catch (std::exception& e) {
26999       {
27000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27001       };
27002     } catch (Dali::DaliException e) {
27003       {
27004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27005       };
27006     } catch (...) {
27007       {
27008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27009       };
27010     }
27011   }
27012
27013 }
27014
27015
27016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27017   void * jresult ;
27018   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27019   Dali::TextureSet result;
27020
27021   arg1 = (Dali::Renderer *)jarg1;
27022   {
27023     try {
27024       result = ((Dali::Renderer const *)arg1)->GetTextures();
27025     } catch (std::out_of_range& e) {
27026       {
27027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27028       };
27029     } catch (std::exception& e) {
27030       {
27031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27032       };
27033     } catch (Dali::DaliException e) {
27034       {
27035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27036       };
27037     } catch (...) {
27038       {
27039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27040       };
27041     }
27042   }
27043
27044   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27045   return jresult;
27046 }
27047
27048
27049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27050   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27051   Dali::Shader *arg2 = 0 ;
27052
27053   arg1 = (Dali::Renderer *)jarg1;
27054   arg2 = (Dali::Shader *)jarg2;
27055   if (!arg2) {
27056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27057     return ;
27058   }
27059   {
27060     try {
27061       (arg1)->SetShader(*arg2);
27062     } catch (std::out_of_range& e) {
27063       {
27064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27065       };
27066     } catch (std::exception& e) {
27067       {
27068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27069       };
27070     } catch (Dali::DaliException e) {
27071       {
27072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27073       };
27074     } catch (...) {
27075       {
27076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27077       };
27078     }
27079   }
27080
27081 }
27082
27083
27084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27085   void * jresult ;
27086   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27087   Dali::Shader result;
27088
27089   arg1 = (Dali::Renderer *)jarg1;
27090   {
27091     try {
27092       result = ((Dali::Renderer const *)arg1)->GetShader();
27093     } catch (std::out_of_range& e) {
27094       {
27095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27096       };
27097     } catch (std::exception& e) {
27098       {
27099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27100       };
27101     } catch (Dali::DaliException e) {
27102       {
27103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27104       };
27105     } catch (...) {
27106       {
27107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27108       };
27109     }
27110   }
27111
27112   jresult = new Dali::Shader((const Dali::Shader &)result);
27113   return jresult;
27114 }
27115
27116
27117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27118   void * jresult ;
27119   Dali::FrameBuffer::Attachment *result = 0 ;
27120
27121   {
27122     try {
27123       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27124     } catch (std::out_of_range& e) {
27125       {
27126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27127       };
27128     } catch (std::exception& e) {
27129       {
27130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27131       };
27132     } catch (Dali::DaliException e) {
27133       {
27134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27135       };
27136     } catch (...) {
27137       {
27138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27139       };
27140     }
27141   }
27142
27143   jresult = (void *)result;
27144   return jresult;
27145 }
27146
27147
27148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27149   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27150
27151   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27152   {
27153     try {
27154       delete arg1;
27155     } catch (std::out_of_range& e) {
27156       {
27157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27158       };
27159     } catch (std::exception& e) {
27160       {
27161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27162       };
27163     } catch (Dali::DaliException e) {
27164       {
27165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27166       };
27167     } catch (...) {
27168       {
27169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27170       };
27171     }
27172   }
27173
27174 }
27175
27176
27177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27178   void * jresult ;
27179   unsigned int arg1 ;
27180   unsigned int arg2 ;
27181   unsigned int arg3 ;
27182   Dali::FrameBuffer result;
27183
27184   arg1 = (unsigned int)jarg1;
27185   arg2 = (unsigned int)jarg2;
27186   arg3 = (unsigned int)jarg3;
27187   {
27188     try {
27189       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27190     } catch (std::out_of_range& e) {
27191       {
27192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27193       };
27194     } catch (std::exception& e) {
27195       {
27196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27197       };
27198     } catch (Dali::DaliException e) {
27199       {
27200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27201       };
27202     } catch (...) {
27203       {
27204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27205       };
27206     }
27207   }
27208
27209   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27210   return jresult;
27211 }
27212
27213
27214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27215   void * jresult ;
27216   Dali::FrameBuffer *result = 0 ;
27217
27218   {
27219     try {
27220       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27221     } catch (std::out_of_range& e) {
27222       {
27223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27224       };
27225     } catch (std::exception& e) {
27226       {
27227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27228       };
27229     } catch (Dali::DaliException e) {
27230       {
27231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27232       };
27233     } catch (...) {
27234       {
27235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27236       };
27237     }
27238   }
27239
27240   jresult = (void *)result;
27241   return jresult;
27242 }
27243
27244
27245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27246   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27247
27248   arg1 = (Dali::FrameBuffer *)jarg1;
27249   {
27250     try {
27251       delete arg1;
27252     } catch (std::out_of_range& e) {
27253       {
27254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27255       };
27256     } catch (std::exception& e) {
27257       {
27258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27259       };
27260     } catch (Dali::DaliException e) {
27261       {
27262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27263       };
27264     } catch (...) {
27265       {
27266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27267       };
27268     }
27269   }
27270
27271 }
27272
27273
27274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27275   void * jresult ;
27276   Dali::FrameBuffer *arg1 = 0 ;
27277   Dali::FrameBuffer *result = 0 ;
27278
27279   arg1 = (Dali::FrameBuffer *)jarg1;
27280   if (!arg1) {
27281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27282     return 0;
27283   }
27284   {
27285     try {
27286       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27287     } catch (std::out_of_range& e) {
27288       {
27289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27290       };
27291     } catch (std::exception& e) {
27292       {
27293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27294       };
27295     } catch (Dali::DaliException e) {
27296       {
27297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27298       };
27299     } catch (...) {
27300       {
27301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27302       };
27303     }
27304   }
27305
27306   jresult = (void *)result;
27307   return jresult;
27308 }
27309
27310
27311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27312   void * jresult ;
27313   Dali::BaseHandle arg1 ;
27314   Dali::BaseHandle *argp1 ;
27315   Dali::FrameBuffer result;
27316
27317   argp1 = (Dali::BaseHandle *)jarg1;
27318   if (!argp1) {
27319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27320     return 0;
27321   }
27322   arg1 = *argp1;
27323   {
27324     try {
27325       result = Dali::FrameBuffer::DownCast(arg1);
27326     } catch (std::out_of_range& e) {
27327       {
27328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27329       };
27330     } catch (std::exception& e) {
27331       {
27332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27333       };
27334     } catch (Dali::DaliException e) {
27335       {
27336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27337       };
27338     } catch (...) {
27339       {
27340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27341       };
27342     }
27343   }
27344
27345   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27346   return jresult;
27347 }
27348
27349
27350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27351   void * jresult ;
27352   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27353   Dali::FrameBuffer *arg2 = 0 ;
27354   Dali::FrameBuffer *result = 0 ;
27355
27356   arg1 = (Dali::FrameBuffer *)jarg1;
27357   arg2 = (Dali::FrameBuffer *)jarg2;
27358   if (!arg2) {
27359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27360     return 0;
27361   }
27362   {
27363     try {
27364       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27365     } catch (std::out_of_range& e) {
27366       {
27367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27368       };
27369     } catch (std::exception& e) {
27370       {
27371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27372       };
27373     } catch (Dali::DaliException e) {
27374       {
27375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27376       };
27377     } catch (...) {
27378       {
27379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27380       };
27381     }
27382   }
27383
27384   jresult = (void *)result;
27385   return jresult;
27386 }
27387
27388
27389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27390   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27391   Dali::Texture *arg2 = 0 ;
27392
27393   arg1 = (Dali::FrameBuffer *)jarg1;
27394   arg2 = (Dali::Texture *)jarg2;
27395   if (!arg2) {
27396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27397     return ;
27398   }
27399   {
27400     try {
27401       (arg1)->AttachColorTexture(*arg2);
27402     } catch (std::out_of_range& e) {
27403       {
27404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27405       };
27406     } catch (std::exception& e) {
27407       {
27408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27409       };
27410     } catch (Dali::DaliException e) {
27411       {
27412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27413       };
27414     } catch (...) {
27415       {
27416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27417       };
27418     }
27419   }
27420
27421 }
27422
27423
27424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27425   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27426   Dali::Texture *arg2 = 0 ;
27427   unsigned int arg3 ;
27428   unsigned int arg4 ;
27429
27430   arg1 = (Dali::FrameBuffer *)jarg1;
27431   arg2 = (Dali::Texture *)jarg2;
27432   if (!arg2) {
27433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27434     return ;
27435   }
27436   arg3 = (unsigned int)jarg3;
27437   arg4 = (unsigned int)jarg4;
27438   {
27439     try {
27440       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27441     } catch (std::out_of_range& e) {
27442       {
27443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27444       };
27445     } catch (std::exception& e) {
27446       {
27447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27448       };
27449     } catch (Dali::DaliException e) {
27450       {
27451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27452       };
27453     } catch (...) {
27454       {
27455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27456       };
27457     }
27458   }
27459
27460 }
27461
27462
27463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27464   void * jresult ;
27465   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27466   Dali::Texture result;
27467
27468   arg1 = (Dali::FrameBuffer *)jarg1;
27469   {
27470     try {
27471       result = (arg1)->GetColorTexture();
27472     } catch (std::out_of_range& e) {
27473       {
27474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27475       };
27476     } catch (std::exception& e) {
27477       {
27478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27479       };
27480     } catch (Dali::DaliException e) {
27481       {
27482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27483       };
27484     } catch (...) {
27485       {
27486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27487       };
27488     }
27489   }
27490
27491   jresult = new Dali::Texture((const Dali::Texture &)result);
27492   return jresult;
27493 }
27494
27495
27496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27497   void * jresult ;
27498   Dali::RenderTaskList *result = 0 ;
27499
27500   {
27501     try {
27502       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27503     } catch (std::out_of_range& e) {
27504       {
27505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27506       };
27507     } catch (std::exception& e) {
27508       {
27509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27510       };
27511     } catch (Dali::DaliException e) {
27512       {
27513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27514       };
27515     } catch (...) {
27516       {
27517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27518       };
27519     }
27520   }
27521
27522   jresult = (void *)result;
27523   return jresult;
27524 }
27525
27526
27527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27528   void * jresult ;
27529   Dali::BaseHandle arg1 ;
27530   Dali::BaseHandle *argp1 ;
27531   Dali::RenderTaskList result;
27532
27533   argp1 = (Dali::BaseHandle *)jarg1;
27534   if (!argp1) {
27535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27536     return 0;
27537   }
27538   arg1 = *argp1;
27539   {
27540     try {
27541       result = Dali::RenderTaskList::DownCast(arg1);
27542     } catch (std::out_of_range& e) {
27543       {
27544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27545       };
27546     } catch (std::exception& e) {
27547       {
27548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27549       };
27550     } catch (Dali::DaliException e) {
27551       {
27552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27553       };
27554     } catch (...) {
27555       {
27556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27557       };
27558     }
27559   }
27560
27561   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27562   return jresult;
27563 }
27564
27565
27566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27567   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27568
27569   arg1 = (Dali::RenderTaskList *)jarg1;
27570   {
27571     try {
27572       delete arg1;
27573     } catch (std::out_of_range& e) {
27574       {
27575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27576       };
27577     } catch (std::exception& e) {
27578       {
27579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27580       };
27581     } catch (Dali::DaliException e) {
27582       {
27583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27584       };
27585     } catch (...) {
27586       {
27587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27588       };
27589     }
27590   }
27591
27592 }
27593
27594
27595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27596   void * jresult ;
27597   Dali::RenderTaskList *arg1 = 0 ;
27598   Dali::RenderTaskList *result = 0 ;
27599
27600   arg1 = (Dali::RenderTaskList *)jarg1;
27601   if (!arg1) {
27602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27603     return 0;
27604   }
27605   {
27606     try {
27607       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27608     } catch (std::out_of_range& e) {
27609       {
27610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27611       };
27612     } catch (std::exception& e) {
27613       {
27614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27615       };
27616     } catch (Dali::DaliException e) {
27617       {
27618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27619       };
27620     } catch (...) {
27621       {
27622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27623       };
27624     }
27625   }
27626
27627   jresult = (void *)result;
27628   return jresult;
27629 }
27630
27631
27632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27633   void * jresult ;
27634   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27635   Dali::RenderTaskList *arg2 = 0 ;
27636   Dali::RenderTaskList *result = 0 ;
27637
27638   arg1 = (Dali::RenderTaskList *)jarg1;
27639   arg2 = (Dali::RenderTaskList *)jarg2;
27640   if (!arg2) {
27641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27642     return 0;
27643   }
27644   {
27645     try {
27646       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27647     } catch (std::out_of_range& e) {
27648       {
27649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27650       };
27651     } catch (std::exception& e) {
27652       {
27653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27654       };
27655     } catch (Dali::DaliException e) {
27656       {
27657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27658       };
27659     } catch (...) {
27660       {
27661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27662       };
27663     }
27664   }
27665
27666   jresult = (void *)result;
27667   return jresult;
27668 }
27669
27670
27671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27672   void * jresult ;
27673   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27674   Dali::RenderTask result;
27675
27676   arg1 = (Dali::RenderTaskList *)jarg1;
27677   {
27678     try {
27679       result = (arg1)->CreateTask();
27680     } catch (std::out_of_range& e) {
27681       {
27682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27683       };
27684     } catch (std::exception& e) {
27685       {
27686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27687       };
27688     } catch (Dali::DaliException e) {
27689       {
27690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27691       };
27692     } catch (...) {
27693       {
27694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27695       };
27696     }
27697   }
27698
27699   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27700   return jresult;
27701 }
27702
27703
27704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27705   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27706   Dali::RenderTask arg2 ;
27707   Dali::RenderTask *argp2 ;
27708
27709   arg1 = (Dali::RenderTaskList *)jarg1;
27710   argp2 = (Dali::RenderTask *)jarg2;
27711   if (!argp2) {
27712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27713     return ;
27714   }
27715   arg2 = *argp2;
27716   {
27717     try {
27718       (arg1)->RemoveTask(arg2);
27719     } catch (std::out_of_range& e) {
27720       {
27721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27722       };
27723     } catch (std::exception& e) {
27724       {
27725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27726       };
27727     } catch (Dali::DaliException e) {
27728       {
27729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27730       };
27731     } catch (...) {
27732       {
27733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27734       };
27735     }
27736   }
27737
27738 }
27739
27740
27741 //// ===============================================end part 1 =================
27742
27743 //// ========================= part 2 ===============================
27744
27745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27746   unsigned int jresult ;
27747   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27748   unsigned int result;
27749
27750   arg1 = (Dali::RenderTaskList *)jarg1;
27751   {
27752     try {
27753       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27754     } catch (std::out_of_range& e) {
27755       {
27756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27757       };
27758     } catch (std::exception& e) {
27759       {
27760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27761       };
27762     } catch (Dali::DaliException e) {
27763       {
27764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27765       };
27766     } catch (...) {
27767       {
27768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27769       };
27770     }
27771   }
27772
27773   jresult = result;
27774   return jresult;
27775 }
27776
27777
27778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27779   void * jresult ;
27780   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27781   unsigned int arg2 ;
27782   Dali::RenderTask result;
27783
27784   arg1 = (Dali::RenderTaskList *)jarg1;
27785   arg2 = (unsigned int)jarg2;
27786   {
27787     try {
27788       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27789     } catch (std::out_of_range& e) {
27790       {
27791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27792       };
27793     } catch (std::exception& e) {
27794       {
27795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27796       };
27797     } catch (Dali::DaliException e) {
27798       {
27799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27800       };
27801     } catch (...) {
27802       {
27803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27804       };
27805     }
27806   }
27807
27808   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27809   return jresult;
27810 }
27811
27812
27813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27814   int jresult ;
27815   int result;
27816
27817   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27818   jresult = (int)result;
27819   return jresult;
27820 }
27821
27822
27823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27824   int jresult ;
27825   int result;
27826
27827   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27828   jresult = (int)result;
27829   return jresult;
27830 }
27831
27832
27833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27834   int jresult ;
27835   int result;
27836
27837   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27838   jresult = (int)result;
27839   return jresult;
27840 }
27841
27842
27843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27844   int jresult ;
27845   int result;
27846
27847   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27848   jresult = (int)result;
27849   return jresult;
27850 }
27851
27852
27853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27854   void * jresult ;
27855   Dali::RenderTask::Property *result = 0 ;
27856
27857   {
27858     try {
27859       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27860     } catch (std::out_of_range& e) {
27861       {
27862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27863       };
27864     } catch (std::exception& e) {
27865       {
27866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27867       };
27868     } catch (Dali::DaliException e) {
27869       {
27870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27871       };
27872     } catch (...) {
27873       {
27874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27875       };
27876     }
27877   }
27878
27879   jresult = (void *)result;
27880   return jresult;
27881 }
27882
27883
27884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27885   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27886
27887   arg1 = (Dali::RenderTask::Property *)jarg1;
27888   {
27889     try {
27890       delete arg1;
27891     } catch (std::out_of_range& e) {
27892       {
27893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27894       };
27895     } catch (std::exception& e) {
27896       {
27897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27898       };
27899     } catch (Dali::DaliException e) {
27900       {
27901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27902       };
27903     } catch (...) {
27904       {
27905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27906       };
27907     }
27908   }
27909
27910 }
27911
27912
27913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27914   void * jresult ;
27915   bool (*result)(Dali::Vector2 &) = 0 ;
27916
27917   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27918   jresult = (void *)result;
27919   return jresult;
27920 }
27921
27922
27923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27924   void * jresult ;
27925   bool (*result)(Dali::Vector2 &) = 0 ;
27926
27927   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27928   jresult = (void *)result;
27929   return jresult;
27930 }
27931
27932
27933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27934   unsigned int jresult ;
27935   bool result;
27936
27937   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27938   jresult = result;
27939   return jresult;
27940 }
27941
27942
27943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27944   unsigned int jresult ;
27945   bool result;
27946
27947   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27948   jresult = result;
27949   return jresult;
27950 }
27951
27952
27953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27954   void * jresult ;
27955   Dali::Vector4 *result = 0 ;
27956
27957   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27958   jresult = (void *)result;
27959   return jresult;
27960 }
27961
27962
27963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27964   unsigned int jresult ;
27965   bool result;
27966
27967   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27968   jresult = result;
27969   return jresult;
27970 }
27971
27972
27973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27974   unsigned int jresult ;
27975   bool result;
27976
27977   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27978   jresult = result;
27979   return jresult;
27980 }
27981
27982
27983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27984   unsigned int jresult ;
27985   unsigned int result;
27986
27987   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27988   jresult = result;
27989   return jresult;
27990 }
27991
27992
27993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27994   void * jresult ;
27995   Dali::RenderTask *result = 0 ;
27996
27997   {
27998     try {
27999       result = (Dali::RenderTask *)new Dali::RenderTask();
28000     } catch (std::out_of_range& e) {
28001       {
28002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28003       };
28004     } catch (std::exception& e) {
28005       {
28006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28007       };
28008     } catch (Dali::DaliException e) {
28009       {
28010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28011       };
28012     } catch (...) {
28013       {
28014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28015       };
28016     }
28017   }
28018
28019   jresult = (void *)result;
28020   return jresult;
28021 }
28022
28023
28024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28025   void * jresult ;
28026   Dali::BaseHandle arg1 ;
28027   Dali::BaseHandle *argp1 ;
28028   Dali::RenderTask result;
28029
28030   argp1 = (Dali::BaseHandle *)jarg1;
28031   if (!argp1) {
28032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28033     return 0;
28034   }
28035   arg1 = *argp1;
28036   {
28037     try {
28038       result = Dali::RenderTask::DownCast(arg1);
28039     } catch (std::out_of_range& e) {
28040       {
28041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28042       };
28043     } catch (std::exception& e) {
28044       {
28045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28046       };
28047     } catch (Dali::DaliException e) {
28048       {
28049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28050       };
28051     } catch (...) {
28052       {
28053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28054       };
28055     }
28056   }
28057
28058   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28059   return jresult;
28060 }
28061
28062
28063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28064   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28065
28066   arg1 = (Dali::RenderTask *)jarg1;
28067   {
28068     try {
28069       delete arg1;
28070     } catch (std::out_of_range& e) {
28071       {
28072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28073       };
28074     } catch (std::exception& e) {
28075       {
28076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28077       };
28078     } catch (Dali::DaliException e) {
28079       {
28080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28081       };
28082     } catch (...) {
28083       {
28084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28085       };
28086     }
28087   }
28088
28089 }
28090
28091
28092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28093   void * jresult ;
28094   Dali::RenderTask *arg1 = 0 ;
28095   Dali::RenderTask *result = 0 ;
28096
28097   arg1 = (Dali::RenderTask *)jarg1;
28098   if (!arg1) {
28099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28100     return 0;
28101   }
28102   {
28103     try {
28104       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28105     } catch (std::out_of_range& e) {
28106       {
28107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28108       };
28109     } catch (std::exception& e) {
28110       {
28111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28112       };
28113     } catch (Dali::DaliException e) {
28114       {
28115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28116       };
28117     } catch (...) {
28118       {
28119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28120       };
28121     }
28122   }
28123
28124   jresult = (void *)result;
28125   return jresult;
28126 }
28127
28128
28129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28130   void * jresult ;
28131   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28132   Dali::RenderTask *arg2 = 0 ;
28133   Dali::RenderTask *result = 0 ;
28134
28135   arg1 = (Dali::RenderTask *)jarg1;
28136   arg2 = (Dali::RenderTask *)jarg2;
28137   if (!arg2) {
28138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28139     return 0;
28140   }
28141   {
28142     try {
28143       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28144     } catch (std::out_of_range& e) {
28145       {
28146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28147       };
28148     } catch (std::exception& e) {
28149       {
28150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28151       };
28152     } catch (Dali::DaliException e) {
28153       {
28154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28155       };
28156     } catch (...) {
28157       {
28158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28159       };
28160     }
28161   }
28162
28163   jresult = (void *)result;
28164   return jresult;
28165 }
28166
28167
28168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28169   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28170   Dali::Actor arg2 ;
28171   Dali::Actor *argp2 ;
28172
28173   arg1 = (Dali::RenderTask *)jarg1;
28174   argp2 = (Dali::Actor *)jarg2;
28175   if (!argp2) {
28176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28177     return ;
28178   }
28179   arg2 = *argp2;
28180   {
28181     try {
28182       (arg1)->SetSourceActor(arg2);
28183     } catch (std::out_of_range& e) {
28184       {
28185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28186       };
28187     } catch (std::exception& e) {
28188       {
28189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28190       };
28191     } catch (Dali::DaliException e) {
28192       {
28193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28194       };
28195     } catch (...) {
28196       {
28197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28198       };
28199     }
28200   }
28201
28202 }
28203
28204
28205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28206   void * jresult ;
28207   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28208   Dali::Actor result;
28209
28210   arg1 = (Dali::RenderTask *)jarg1;
28211   {
28212     try {
28213       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28214     } catch (std::out_of_range& e) {
28215       {
28216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28217       };
28218     } catch (std::exception& e) {
28219       {
28220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28221       };
28222     } catch (Dali::DaliException e) {
28223       {
28224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28225       };
28226     } catch (...) {
28227       {
28228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28229       };
28230     }
28231   }
28232
28233   jresult = new Dali::Actor((const Dali::Actor &)result);
28234   return jresult;
28235 }
28236
28237
28238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28239   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28240   bool arg2 ;
28241
28242   arg1 = (Dali::RenderTask *)jarg1;
28243   arg2 = jarg2 ? true : false;
28244   {
28245     try {
28246       (arg1)->SetExclusive(arg2);
28247     } catch (std::out_of_range& e) {
28248       {
28249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28250       };
28251     } catch (std::exception& e) {
28252       {
28253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28254       };
28255     } catch (Dali::DaliException e) {
28256       {
28257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28258       };
28259     } catch (...) {
28260       {
28261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28262       };
28263     }
28264   }
28265
28266 }
28267
28268
28269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28270   unsigned int jresult ;
28271   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28272   bool result;
28273
28274   arg1 = (Dali::RenderTask *)jarg1;
28275   {
28276     try {
28277       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28278     } catch (std::out_of_range& e) {
28279       {
28280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28281       };
28282     } catch (std::exception& e) {
28283       {
28284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28285       };
28286     } catch (Dali::DaliException e) {
28287       {
28288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28289       };
28290     } catch (...) {
28291       {
28292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28293       };
28294     }
28295   }
28296
28297   jresult = result;
28298   return jresult;
28299 }
28300
28301
28302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28303   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28304   bool arg2 ;
28305
28306   arg1 = (Dali::RenderTask *)jarg1;
28307   arg2 = jarg2 ? true : false;
28308   {
28309     try {
28310       (arg1)->SetInputEnabled(arg2);
28311     } catch (std::out_of_range& e) {
28312       {
28313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28314       };
28315     } catch (std::exception& e) {
28316       {
28317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28318       };
28319     } catch (Dali::DaliException e) {
28320       {
28321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28322       };
28323     } catch (...) {
28324       {
28325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28326       };
28327     }
28328   }
28329
28330 }
28331
28332
28333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28334   unsigned int jresult ;
28335   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28336   bool result;
28337
28338   arg1 = (Dali::RenderTask *)jarg1;
28339   {
28340     try {
28341       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28342     } catch (std::out_of_range& e) {
28343       {
28344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28345       };
28346     } catch (std::exception& e) {
28347       {
28348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28349       };
28350     } catch (Dali::DaliException e) {
28351       {
28352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28353       };
28354     } catch (...) {
28355       {
28356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28357       };
28358     }
28359   }
28360
28361   jresult = result;
28362   return jresult;
28363 }
28364
28365
28366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28367   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28368   Dali::CameraActor arg2 ;
28369   Dali::CameraActor *argp2 ;
28370
28371   arg1 = (Dali::RenderTask *)jarg1;
28372   argp2 = (Dali::CameraActor *)jarg2;
28373   if (!argp2) {
28374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28375     return ;
28376   }
28377   arg2 = *argp2;
28378   {
28379     try {
28380       (arg1)->SetCameraActor(arg2);
28381     } catch (std::out_of_range& e) {
28382       {
28383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28384       };
28385     } catch (std::exception& e) {
28386       {
28387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28388       };
28389     } catch (Dali::DaliException e) {
28390       {
28391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28392       };
28393     } catch (...) {
28394       {
28395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28396       };
28397     }
28398   }
28399
28400 }
28401
28402
28403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28404   void * jresult ;
28405   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28406   Dali::CameraActor result;
28407
28408   arg1 = (Dali::RenderTask *)jarg1;
28409   {
28410     try {
28411       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28412     } catch (std::out_of_range& e) {
28413       {
28414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28415       };
28416     } catch (std::exception& e) {
28417       {
28418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28419       };
28420     } catch (Dali::DaliException e) {
28421       {
28422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28423       };
28424     } catch (...) {
28425       {
28426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28427       };
28428     }
28429   }
28430
28431   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28432   return jresult;
28433 }
28434
28435
28436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28437   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28438   Dali::FrameBuffer arg2 ;
28439   Dali::FrameBuffer *argp2 ;
28440
28441   arg1 = (Dali::RenderTask *)jarg1;
28442   argp2 = (Dali::FrameBuffer *)jarg2;
28443   if (!argp2) {
28444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28445     return ;
28446   }
28447   arg2 = *argp2;
28448   {
28449     try {
28450       (arg1)->SetFrameBuffer(arg2);
28451     } catch (std::out_of_range& e) {
28452       {
28453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28454       };
28455     } catch (std::exception& e) {
28456       {
28457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28458       };
28459     } catch (Dali::DaliException e) {
28460       {
28461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28462       };
28463     } catch (...) {
28464       {
28465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28466       };
28467     }
28468   }
28469
28470 }
28471
28472
28473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28474   void * jresult ;
28475   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28476   Dali::FrameBuffer result;
28477
28478   arg1 = (Dali::RenderTask *)jarg1;
28479   {
28480     try {
28481       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28482     } catch (std::out_of_range& e) {
28483       {
28484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28485       };
28486     } catch (std::exception& e) {
28487       {
28488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28489       };
28490     } catch (Dali::DaliException e) {
28491       {
28492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28493       };
28494     } catch (...) {
28495       {
28496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28497       };
28498     }
28499   }
28500
28501   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28502   return jresult;
28503 }
28504
28505
28506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28507   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28508   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28509
28510   arg1 = (Dali::RenderTask *)jarg1;
28511   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28512   {
28513     try {
28514       (arg1)->SetScreenToFrameBufferFunction(arg2);
28515     } catch (std::out_of_range& e) {
28516       {
28517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28518       };
28519     } catch (std::exception& e) {
28520       {
28521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28522       };
28523     } catch (Dali::DaliException e) {
28524       {
28525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28526       };
28527     } catch (...) {
28528       {
28529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28530       };
28531     }
28532   }
28533
28534 }
28535
28536
28537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28538   void * jresult ;
28539   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28540   Dali::RenderTask::ScreenToFrameBufferFunction result;
28541
28542   arg1 = (Dali::RenderTask *)jarg1;
28543   {
28544     try {
28545       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28546     } catch (std::out_of_range& e) {
28547       {
28548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28549       };
28550     } catch (std::exception& e) {
28551       {
28552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28553       };
28554     } catch (Dali::DaliException e) {
28555       {
28556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28557       };
28558     } catch (...) {
28559       {
28560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28561       };
28562     }
28563   }
28564
28565   jresult = (void *)result;
28566   return jresult;
28567 }
28568
28569
28570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28571   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28572   Dali::Actor arg2 ;
28573   Dali::Actor *argp2 ;
28574
28575   arg1 = (Dali::RenderTask *)jarg1;
28576   argp2 = (Dali::Actor *)jarg2;
28577   if (!argp2) {
28578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28579     return ;
28580   }
28581   arg2 = *argp2;
28582   {
28583     try {
28584       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28585     } catch (std::out_of_range& e) {
28586       {
28587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28588       };
28589     } catch (std::exception& e) {
28590       {
28591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28592       };
28593     } catch (Dali::DaliException e) {
28594       {
28595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28596       };
28597     } catch (...) {
28598       {
28599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28600       };
28601     }
28602   }
28603
28604 }
28605
28606
28607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28608   void * jresult ;
28609   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28610   Dali::Actor result;
28611
28612   arg1 = (Dali::RenderTask *)jarg1;
28613   {
28614     try {
28615       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28616     } catch (std::out_of_range& e) {
28617       {
28618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28619       };
28620     } catch (std::exception& e) {
28621       {
28622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28623       };
28624     } catch (Dali::DaliException e) {
28625       {
28626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28627       };
28628     } catch (...) {
28629       {
28630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28631       };
28632     }
28633   }
28634
28635   jresult = new Dali::Actor((const Dali::Actor &)result);
28636   return jresult;
28637 }
28638
28639
28640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28641   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28642   Dali::Vector2 arg2 ;
28643   Dali::Vector2 *argp2 ;
28644
28645   arg1 = (Dali::RenderTask *)jarg1;
28646   argp2 = (Dali::Vector2 *)jarg2;
28647   if (!argp2) {
28648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28649     return ;
28650   }
28651   arg2 = *argp2;
28652   {
28653     try {
28654       (arg1)->SetViewportPosition(arg2);
28655     } catch (std::out_of_range& e) {
28656       {
28657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28658       };
28659     } catch (std::exception& e) {
28660       {
28661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28662       };
28663     } catch (Dali::DaliException e) {
28664       {
28665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28666       };
28667     } catch (...) {
28668       {
28669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28670       };
28671     }
28672   }
28673
28674 }
28675
28676
28677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28678   void * jresult ;
28679   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28680   Dali::Vector2 result;
28681
28682   arg1 = (Dali::RenderTask *)jarg1;
28683   {
28684     try {
28685       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28686     } catch (std::out_of_range& e) {
28687       {
28688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28689       };
28690     } catch (std::exception& e) {
28691       {
28692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28693       };
28694     } catch (Dali::DaliException e) {
28695       {
28696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28697       };
28698     } catch (...) {
28699       {
28700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28701       };
28702     }
28703   }
28704
28705   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28706   return jresult;
28707 }
28708
28709
28710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28711   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28712   Dali::Vector2 arg2 ;
28713   Dali::Vector2 *argp2 ;
28714
28715   arg1 = (Dali::RenderTask *)jarg1;
28716   argp2 = (Dali::Vector2 *)jarg2;
28717   if (!argp2) {
28718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28719     return ;
28720   }
28721   arg2 = *argp2;
28722   {
28723     try {
28724       (arg1)->SetViewportSize(arg2);
28725     } catch (std::out_of_range& e) {
28726       {
28727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28728       };
28729     } catch (std::exception& e) {
28730       {
28731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28732       };
28733     } catch (Dali::DaliException e) {
28734       {
28735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28736       };
28737     } catch (...) {
28738       {
28739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28740       };
28741     }
28742   }
28743
28744 }
28745
28746
28747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28748   void * jresult ;
28749   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28750   Dali::Vector2 result;
28751
28752   arg1 = (Dali::RenderTask *)jarg1;
28753   {
28754     try {
28755       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28756     } catch (std::out_of_range& e) {
28757       {
28758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28759       };
28760     } catch (std::exception& e) {
28761       {
28762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28763       };
28764     } catch (Dali::DaliException e) {
28765       {
28766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28767       };
28768     } catch (...) {
28769       {
28770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28771       };
28772     }
28773   }
28774
28775   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28776   return jresult;
28777 }
28778
28779
28780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28781   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28782   Dali::Viewport arg2 ;
28783   Dali::Viewport *argp2 ;
28784
28785   arg1 = (Dali::RenderTask *)jarg1;
28786   argp2 = (Dali::Viewport *)jarg2;
28787   if (!argp2) {
28788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28789     return ;
28790   }
28791   arg2 = *argp2;
28792   {
28793     try {
28794       (arg1)->SetViewport(arg2);
28795     } catch (std::out_of_range& e) {
28796       {
28797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28798       };
28799     } catch (std::exception& e) {
28800       {
28801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28802       };
28803     } catch (Dali::DaliException e) {
28804       {
28805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28806       };
28807     } catch (...) {
28808       {
28809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28810       };
28811     }
28812   }
28813
28814 }
28815
28816
28817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28818   void * jresult ;
28819   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28820   Dali::Viewport result;
28821
28822   arg1 = (Dali::RenderTask *)jarg1;
28823   {
28824     try {
28825       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28826     } catch (std::out_of_range& e) {
28827       {
28828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28829       };
28830     } catch (std::exception& e) {
28831       {
28832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28833       };
28834     } catch (Dali::DaliException e) {
28835       {
28836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28837       };
28838     } catch (...) {
28839       {
28840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28841       };
28842     }
28843   }
28844
28845   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28846   return jresult;
28847 }
28848
28849
28850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28851   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28852   Dali::Vector4 *arg2 = 0 ;
28853
28854   arg1 = (Dali::RenderTask *)jarg1;
28855   arg2 = (Dali::Vector4 *)jarg2;
28856   if (!arg2) {
28857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28858     return ;
28859   }
28860   {
28861     try {
28862       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28863     } catch (std::out_of_range& e) {
28864       {
28865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28866       };
28867     } catch (std::exception& e) {
28868       {
28869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28870       };
28871     } catch (Dali::DaliException e) {
28872       {
28873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28874       };
28875     } catch (...) {
28876       {
28877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28878       };
28879     }
28880   }
28881
28882 }
28883
28884
28885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28886   void * jresult ;
28887   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28888   Dali::Vector4 result;
28889
28890   arg1 = (Dali::RenderTask *)jarg1;
28891   {
28892     try {
28893       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28894     } catch (std::out_of_range& e) {
28895       {
28896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28897       };
28898     } catch (std::exception& e) {
28899       {
28900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28901       };
28902     } catch (Dali::DaliException e) {
28903       {
28904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28905       };
28906     } catch (...) {
28907       {
28908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28909       };
28910     }
28911   }
28912
28913   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28914   return jresult;
28915 }
28916
28917
28918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28919   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28920   bool arg2 ;
28921
28922   arg1 = (Dali::RenderTask *)jarg1;
28923   arg2 = jarg2 ? true : false;
28924   {
28925     try {
28926       (arg1)->SetClearEnabled(arg2);
28927     } catch (std::out_of_range& e) {
28928       {
28929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28930       };
28931     } catch (std::exception& e) {
28932       {
28933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28934       };
28935     } catch (Dali::DaliException e) {
28936       {
28937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28938       };
28939     } catch (...) {
28940       {
28941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28942       };
28943     }
28944   }
28945
28946 }
28947
28948
28949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28950   unsigned int jresult ;
28951   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28952   bool result;
28953
28954   arg1 = (Dali::RenderTask *)jarg1;
28955   {
28956     try {
28957       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28958     } catch (std::out_of_range& e) {
28959       {
28960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28961       };
28962     } catch (std::exception& e) {
28963       {
28964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28965       };
28966     } catch (Dali::DaliException e) {
28967       {
28968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28969       };
28970     } catch (...) {
28971       {
28972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28973       };
28974     }
28975   }
28976
28977   jresult = result;
28978   return jresult;
28979 }
28980
28981
28982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28983   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28984   bool arg2 ;
28985
28986   arg1 = (Dali::RenderTask *)jarg1;
28987   arg2 = jarg2 ? true : false;
28988   {
28989     try {
28990       (arg1)->SetCullMode(arg2);
28991     } catch (std::out_of_range& e) {
28992       {
28993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28994       };
28995     } catch (std::exception& e) {
28996       {
28997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28998       };
28999     } catch (Dali::DaliException e) {
29000       {
29001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29002       };
29003     } catch (...) {
29004       {
29005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29006       };
29007     }
29008   }
29009
29010 }
29011
29012
29013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29014   unsigned int jresult ;
29015   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29016   bool result;
29017
29018   arg1 = (Dali::RenderTask *)jarg1;
29019   {
29020     try {
29021       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29022     } catch (std::out_of_range& e) {
29023       {
29024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29025       };
29026     } catch (std::exception& e) {
29027       {
29028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29029       };
29030     } catch (Dali::DaliException e) {
29031       {
29032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29033       };
29034     } catch (...) {
29035       {
29036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29037       };
29038     }
29039   }
29040
29041   jresult = result;
29042   return jresult;
29043 }
29044
29045
29046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29047   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29048   unsigned int arg2 ;
29049
29050   arg1 = (Dali::RenderTask *)jarg1;
29051   arg2 = (unsigned int)jarg2;
29052   {
29053     try {
29054       (arg1)->SetRefreshRate(arg2);
29055     } catch (std::out_of_range& e) {
29056       {
29057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29058       };
29059     } catch (std::exception& e) {
29060       {
29061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29062       };
29063     } catch (Dali::DaliException e) {
29064       {
29065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29066       };
29067     } catch (...) {
29068       {
29069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29070       };
29071     }
29072   }
29073
29074 }
29075
29076
29077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29078   unsigned int jresult ;
29079   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29080   unsigned int result;
29081
29082   arg1 = (Dali::RenderTask *)jarg1;
29083   {
29084     try {
29085       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29086     } catch (std::out_of_range& e) {
29087       {
29088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29089       };
29090     } catch (std::exception& e) {
29091       {
29092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29093       };
29094     } catch (Dali::DaliException e) {
29095       {
29096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29097       };
29098     } catch (...) {
29099       {
29100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29101       };
29102     }
29103   }
29104
29105   jresult = result;
29106   return jresult;
29107 }
29108
29109
29110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29111   unsigned int jresult ;
29112   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29113   Dali::Vector3 *arg2 = 0 ;
29114   float *arg3 = 0 ;
29115   float *arg4 = 0 ;
29116   bool result;
29117
29118   arg1 = (Dali::RenderTask *)jarg1;
29119   arg2 = (Dali::Vector3 *)jarg2;
29120   if (!arg2) {
29121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29122     return 0;
29123   }
29124   arg3 = (float *)jarg3;
29125   arg4 = (float *)jarg4;
29126   {
29127     try {
29128       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29129     } catch (std::out_of_range& e) {
29130       {
29131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29132       };
29133     } catch (std::exception& e) {
29134       {
29135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29136       };
29137     } catch (Dali::DaliException e) {
29138       {
29139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29140       };
29141     } catch (...) {
29142       {
29143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29144       };
29145     }
29146   }
29147
29148   jresult = result;
29149   return jresult;
29150 }
29151
29152
29153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29154   unsigned int jresult ;
29155   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29156   Dali::Actor arg2 ;
29157   float arg3 ;
29158   float arg4 ;
29159   float *arg5 = 0 ;
29160   float *arg6 = 0 ;
29161   Dali::Actor *argp2 ;
29162   bool result;
29163
29164   arg1 = (Dali::RenderTask *)jarg1;
29165   argp2 = (Dali::Actor *)jarg2;
29166   if (!argp2) {
29167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29168     return 0;
29169   }
29170   arg2 = *argp2;
29171   arg3 = (float)jarg3;
29172   arg4 = (float)jarg4;
29173   arg5 = (float *)jarg5;
29174   arg6 = (float *)jarg6;
29175   {
29176     try {
29177       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29178     } catch (std::out_of_range& e) {
29179       {
29180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29181       };
29182     } catch (std::exception& e) {
29183       {
29184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29185       };
29186     } catch (Dali::DaliException e) {
29187       {
29188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29189       };
29190     } catch (...) {
29191       {
29192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29193       };
29194     }
29195   }
29196
29197   jresult = result;
29198   return jresult;
29199 }
29200
29201
29202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29203   void * jresult ;
29204   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29205   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29206
29207   arg1 = (Dali::RenderTask *)jarg1;
29208   {
29209     try {
29210       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29211     } catch (std::out_of_range& e) {
29212       {
29213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29214       };
29215     } catch (std::exception& e) {
29216       {
29217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29218       };
29219     } catch (Dali::DaliException e) {
29220       {
29221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29222       };
29223     } catch (...) {
29224       {
29225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29226       };
29227     }
29228   }
29229
29230   jresult = (void *)result;
29231   return jresult;
29232 }
29233
29234
29235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29236   void * jresult ;
29237   int arg1 ;
29238   Dali::TouchPoint::State arg2 ;
29239   float arg3 ;
29240   float arg4 ;
29241   Dali::TouchPoint *result = 0 ;
29242
29243   arg1 = (int)jarg1;
29244   arg2 = (Dali::TouchPoint::State)jarg2;
29245   arg3 = (float)jarg3;
29246   arg4 = (float)jarg4;
29247   {
29248     try {
29249       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29250     } catch (std::out_of_range& e) {
29251       {
29252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29253       };
29254     } catch (std::exception& e) {
29255       {
29256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29257       };
29258     } catch (Dali::DaliException e) {
29259       {
29260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29261       };
29262     } catch (...) {
29263       {
29264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29265       };
29266     }
29267   }
29268
29269   jresult = (void *)result;
29270   return jresult;
29271 }
29272
29273
29274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29275   void * jresult ;
29276   int arg1 ;
29277   Dali::TouchPoint::State arg2 ;
29278   float arg3 ;
29279   float arg4 ;
29280   float arg5 ;
29281   float arg6 ;
29282   Dali::TouchPoint *result = 0 ;
29283
29284   arg1 = (int)jarg1;
29285   arg2 = (Dali::TouchPoint::State)jarg2;
29286   arg3 = (float)jarg3;
29287   arg4 = (float)jarg4;
29288   arg5 = (float)jarg5;
29289   arg6 = (float)jarg6;
29290   {
29291     try {
29292       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29293     } catch (std::out_of_range& e) {
29294       {
29295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29296       };
29297     } catch (std::exception& e) {
29298       {
29299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29300       };
29301     } catch (Dali::DaliException e) {
29302       {
29303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29304       };
29305     } catch (...) {
29306       {
29307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29308       };
29309     }
29310   }
29311
29312   jresult = (void *)result;
29313   return jresult;
29314 }
29315
29316
29317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29318   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29319
29320   arg1 = (Dali::TouchPoint *)jarg1;
29321   {
29322     try {
29323       delete arg1;
29324     } catch (std::out_of_range& e) {
29325       {
29326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29327       };
29328     } catch (std::exception& e) {
29329       {
29330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29331       };
29332     } catch (Dali::DaliException e) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29335       };
29336     } catch (...) {
29337       {
29338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29339       };
29340     }
29341   }
29342
29343 }
29344
29345
29346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29347   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29348   int arg2 ;
29349
29350   arg1 = (Dali::TouchPoint *)jarg1;
29351   arg2 = (int)jarg2;
29352   if (arg1) (arg1)->deviceId = arg2;
29353 }
29354
29355
29356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29357   int jresult ;
29358   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29359   int result;
29360
29361   arg1 = (Dali::TouchPoint *)jarg1;
29362   result = (int) ((arg1)->deviceId);
29363   jresult = result;
29364   return jresult;
29365 }
29366
29367
29368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29369   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29370   Dali::TouchPoint::State arg2 ;
29371
29372   arg1 = (Dali::TouchPoint *)jarg1;
29373   arg2 = (Dali::TouchPoint::State)jarg2;
29374   if (arg1) (arg1)->state = arg2;
29375 }
29376
29377
29378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29379   int jresult ;
29380   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29381   Dali::TouchPoint::State result;
29382
29383   arg1 = (Dali::TouchPoint *)jarg1;
29384   result = (Dali::TouchPoint::State) ((arg1)->state);
29385   jresult = (int)result;
29386   return jresult;
29387 }
29388
29389
29390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29391   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29392   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29393
29394   arg1 = (Dali::TouchPoint *)jarg1;
29395   arg2 = (Dali::Actor *)jarg2;
29396   if (arg1) (arg1)->hitActor = *arg2;
29397 }
29398
29399
29400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29401   void * jresult ;
29402   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29403   Dali::Actor *result = 0 ;
29404
29405   arg1 = (Dali::TouchPoint *)jarg1;
29406   result = (Dali::Actor *)& ((arg1)->hitActor);
29407   jresult = (void *)result;
29408   return jresult;
29409 }
29410
29411
29412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29413   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29414   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29415
29416   arg1 = (Dali::TouchPoint *)jarg1;
29417   arg2 = (Dali::Vector2 *)jarg2;
29418   if (arg1) (arg1)->local = *arg2;
29419 }
29420
29421
29422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29423   void * jresult ;
29424   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29425   Dali::Vector2 *result = 0 ;
29426
29427   arg1 = (Dali::TouchPoint *)jarg1;
29428   result = (Dali::Vector2 *)& ((arg1)->local);
29429   jresult = (void *)result;
29430   return jresult;
29431 }
29432
29433
29434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29435   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29436   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29437
29438   arg1 = (Dali::TouchPoint *)jarg1;
29439   arg2 = (Dali::Vector2 *)jarg2;
29440   if (arg1) (arg1)->screen = *arg2;
29441 }
29442
29443
29444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29445   void * jresult ;
29446   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29447   Dali::Vector2 *result = 0 ;
29448
29449   arg1 = (Dali::TouchPoint *)jarg1;
29450   result = (Dali::Vector2 *)& ((arg1)->screen);
29451   jresult = (void *)result;
29452   return jresult;
29453 }
29454
29455
29456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29457   void * jresult ;
29458   Dali::TouchEvent *result = 0 ;
29459
29460   {
29461     try {
29462       result = (Dali::TouchEvent *)new Dali::TouchEvent();
29463     } catch (std::out_of_range& e) {
29464       {
29465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29466       };
29467     } catch (std::exception& e) {
29468       {
29469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29470       };
29471     } catch (Dali::DaliException e) {
29472       {
29473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29474       };
29475     } catch (...) {
29476       {
29477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29478       };
29479     }
29480   }
29481
29482   jresult = (void *)result;
29483   return jresult;
29484 }
29485
29486
29487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29488   void * jresult ;
29489   Dali::TouchEvent *arg1 = 0 ;
29490   Dali::TouchEvent *result = 0 ;
29491
29492   arg1 = (Dali::TouchEvent *)jarg1;
29493   if (!arg1) {
29494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29495     return 0;
29496   }
29497   {
29498     try {
29499       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
29500     } catch (std::out_of_range& e) {
29501       {
29502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29503       };
29504     } catch (std::exception& e) {
29505       {
29506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29507       };
29508     } catch (Dali::DaliException e) {
29509       {
29510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29511       };
29512     } catch (...) {
29513       {
29514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29515       };
29516     }
29517   }
29518
29519   jresult = (void *)result;
29520   return jresult;
29521 }
29522
29523
29524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29525   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29526
29527   arg1 = (Dali::TouchEvent *)jarg1;
29528   {
29529     try {
29530       delete arg1;
29531     } catch (std::out_of_range& e) {
29532       {
29533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29534       };
29535     } catch (std::exception& e) {
29536       {
29537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29538       };
29539     } catch (Dali::DaliException e) {
29540       {
29541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29542       };
29543     } catch (...) {
29544       {
29545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29546       };
29547     }
29548   }
29549
29550 }
29551
29552
29553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29554   void * jresult ;
29555   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29556   Dali::TouchEvent *arg2 = 0 ;
29557   Dali::TouchEvent *result = 0 ;
29558
29559   arg1 = (Dali::TouchEvent *)jarg1;
29560   arg2 = (Dali::TouchEvent *)jarg2;
29561   if (!arg2) {
29562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29563     return 0;
29564   }
29565   {
29566     try {
29567       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
29568     } catch (std::out_of_range& e) {
29569       {
29570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29571       };
29572     } catch (std::exception& e) {
29573       {
29574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29575       };
29576     } catch (Dali::DaliException e) {
29577       {
29578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29579       };
29580     } catch (...) {
29581       {
29582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29583       };
29584     }
29585   }
29586
29587   jresult = (void *)result;
29588   return jresult;
29589 }
29590
29591
29592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29593   unsigned long jresult ;
29594   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29595   unsigned long result;
29596
29597   arg1 = (Dali::TouchEvent *)jarg1;
29598   {
29599     try {
29600       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
29601     } catch (std::out_of_range& e) {
29602       {
29603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29604       };
29605     } catch (std::exception& e) {
29606       {
29607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29608       };
29609     } catch (Dali::DaliException e) {
29610       {
29611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29612       };
29613     } catch (...) {
29614       {
29615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29616       };
29617     }
29618   }
29619
29620   jresult = (unsigned long)result;
29621   return jresult;
29622 }
29623
29624
29625 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29626   unsigned long jresult ;
29627   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29628   std::size_t result;
29629
29630   arg1 = (Dali::TouchEvent *)jarg1;
29631   {
29632     try {
29633       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
29634     } catch (std::out_of_range& e) {
29635       {
29636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29637       };
29638     } catch (std::exception& e) {
29639       {
29640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29641       };
29642     } catch (Dali::DaliException e) {
29643       {
29644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29645       };
29646     } catch (...) {
29647       {
29648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29649       };
29650     }
29651   }
29652
29653   jresult = (unsigned long)result;
29654   return jresult;
29655 }
29656
29657
29658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29659   int jresult ;
29660   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29661   std::size_t arg2 ;
29662   int32_t result;
29663
29664   arg1 = (Dali::TouchEvent *)jarg1;
29665   arg2 = (std::size_t)jarg2;
29666   {
29667     try {
29668       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
29669     } catch (std::out_of_range& e) {
29670       {
29671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29672       };
29673     } catch (std::exception& e) {
29674       {
29675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29676       };
29677     } catch (Dali::DaliException e) {
29678       {
29679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29680       };
29681     } catch (...) {
29682       {
29683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29684       };
29685     }
29686   }
29687
29688   jresult = result;
29689   return jresult;
29690 }
29691
29692
29693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29694   int jresult ;
29695   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29696   std::size_t arg2 ;
29697   Dali::PointState::Type result;
29698
29699   arg1 = (Dali::TouchEvent *)jarg1;
29700   arg2 = (std::size_t)jarg2;
29701   {
29702     try {
29703       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
29704     } catch (std::out_of_range& e) {
29705       {
29706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29707       };
29708     } catch (std::exception& e) {
29709       {
29710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29711       };
29712     } catch (Dali::DaliException e) {
29713       {
29714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29715       };
29716     } catch (...) {
29717       {
29718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29719       };
29720     }
29721   }
29722
29723   jresult = (int)result;
29724   return jresult;
29725 }
29726
29727
29728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29729   void * jresult ;
29730   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29731   std::size_t arg2 ;
29732   Dali::Actor result;
29733
29734   arg1 = (Dali::TouchEvent *)jarg1;
29735   arg2 = (std::size_t)jarg2;
29736   {
29737     try {
29738       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
29739     } catch (std::out_of_range& e) {
29740       {
29741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29742       };
29743     } catch (std::exception& e) {
29744       {
29745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29746       };
29747     } catch (Dali::DaliException e) {
29748       {
29749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29750       };
29751     } catch (...) {
29752       {
29753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29754       };
29755     }
29756   }
29757
29758   jresult = new Dali::Actor((const Dali::Actor &)result);
29759   return jresult;
29760 }
29761
29762
29763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29764   void * jresult ;
29765   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29766   std::size_t arg2 ;
29767   Dali::Vector2 *result = 0 ;
29768
29769   arg1 = (Dali::TouchEvent *)jarg1;
29770   arg2 = (std::size_t)jarg2;
29771   {
29772     try {
29773       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
29774     } catch (std::out_of_range& e) {
29775       {
29776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29777       };
29778     } catch (std::exception& e) {
29779       {
29780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29781       };
29782     } catch (Dali::DaliException e) {
29783       {
29784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29785       };
29786     } catch (...) {
29787       {
29788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29789       };
29790     }
29791   }
29792
29793   jresult = (void *)result;
29794   return jresult;
29795 }
29796
29797
29798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29799   void * jresult ;
29800   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29801   std::size_t arg2 ;
29802   Dali::Vector2 *result = 0 ;
29803
29804   arg1 = (Dali::TouchEvent *)jarg1;
29805   arg2 = (std::size_t)jarg2;
29806   {
29807     try {
29808       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
29809     } catch (std::out_of_range& e) {
29810       {
29811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29812       };
29813     } catch (std::exception& e) {
29814       {
29815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29816       };
29817     } catch (Dali::DaliException e) {
29818       {
29819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29820       };
29821     } catch (...) {
29822       {
29823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29824       };
29825     }
29826   }
29827
29828   jresult = (void *)result;
29829   return jresult;
29830 }
29831
29832
29833 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29834   float jresult ;
29835   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29836   std::size_t arg2 ;
29837   float result;
29838
29839   arg1 = (Dali::TouchEvent *)jarg1;
29840   arg2 = (std::size_t)jarg2;
29841   {
29842     try {
29843       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
29844     } catch (std::out_of_range& e) {
29845       {
29846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29847       };
29848     } catch (std::exception& e) {
29849       {
29850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29851       };
29852     } catch (Dali::DaliException e) {
29853       {
29854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29855       };
29856     } catch (...) {
29857       {
29858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29859       };
29860     }
29861   }
29862
29863   jresult = result;
29864   return jresult;
29865 }
29866
29867
29868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29869   void * jresult ;
29870   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29871   std::size_t arg2 ;
29872   Dali::Vector2 *result = 0 ;
29873
29874   arg1 = (Dali::TouchEvent *)jarg1;
29875   arg2 = (std::size_t)jarg2;
29876   {
29877     try {
29878       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
29879     } catch (std::out_of_range& e) {
29880       {
29881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29882       };
29883     } catch (std::exception& e) {
29884       {
29885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29886       };
29887     } catch (Dali::DaliException e) {
29888       {
29889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29890       };
29891     } catch (...) {
29892       {
29893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29894       };
29895     }
29896   }
29897
29898   jresult = (void *)result;
29899   return jresult;
29900 }
29901
29902
29903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29904   float jresult ;
29905   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29906   std::size_t arg2 ;
29907   float result;
29908
29909   arg1 = (Dali::TouchEvent *)jarg1;
29910   arg2 = (std::size_t)jarg2;
29911   {
29912     try {
29913       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
29914     } catch (std::out_of_range& e) {
29915       {
29916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29917       };
29918     } catch (std::exception& e) {
29919       {
29920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29921       };
29922     } catch (Dali::DaliException e) {
29923       {
29924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29925       };
29926     } catch (...) {
29927       {
29928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29929       };
29930     }
29931   }
29932
29933   jresult = result;
29934   return jresult;
29935 }
29936
29937
29938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29939   void * jresult ;
29940   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29941   std::size_t arg2 ;
29942   Dali::Degree result;
29943
29944   arg1 = (Dali::TouchEvent *)jarg1;
29945   arg2 = (std::size_t)jarg2;
29946   {
29947     try {
29948       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
29949     } catch (std::out_of_range& e) {
29950       {
29951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29952       };
29953     } catch (std::exception& e) {
29954       {
29955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29956       };
29957     } catch (Dali::DaliException e) {
29958       {
29959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29960       };
29961     } catch (...) {
29962       {
29963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29964       };
29965     }
29966   }
29967
29968   jresult = new Dali::Degree((const Dali::Degree &)result);
29969   return jresult;
29970 }
29971
29972
29973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29974   int jresult ;
29975   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29976   std::size_t arg2 ;
29977   Dali::MouseButton::Type result;
29978
29979   arg1 = (Dali::TouchEvent *)jarg1;
29980   arg2 = (std::size_t)jarg2;
29981   {
29982     try {
29983       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
29984     } catch (std::out_of_range& e) {
29985       {
29986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29987       };
29988     } catch (std::exception& e) {
29989       {
29990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29991       };
29992     } catch (Dali::DaliException e) {
29993       {
29994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29995       };
29996     } catch (...) {
29997       {
29998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29999       };
30000     }
30001   }
30002
30003   jresult = static_cast< int >(result);
30004   return jresult;
30005 }
30006
30007
30008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30009   void * jresult ;
30010   Dali::GestureDetector *result = 0 ;
30011
30012   {
30013     try {
30014       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30015     } catch (std::out_of_range& e) {
30016       {
30017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30018       };
30019     } catch (std::exception& e) {
30020       {
30021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30022       };
30023     } catch (Dali::DaliException e) {
30024       {
30025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30026       };
30027     } catch (...) {
30028       {
30029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30030       };
30031     }
30032   }
30033
30034   jresult = (void *)result;
30035   return jresult;
30036 }
30037
30038
30039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30040   void * jresult ;
30041   Dali::BaseHandle arg1 ;
30042   Dali::BaseHandle *argp1 ;
30043   Dali::GestureDetector result;
30044
30045   argp1 = (Dali::BaseHandle *)jarg1;
30046   if (!argp1) {
30047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30048     return 0;
30049   }
30050   arg1 = *argp1;
30051   {
30052     try {
30053       result = Dali::GestureDetector::DownCast(arg1);
30054     } catch (std::out_of_range& e) {
30055       {
30056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30057       };
30058     } catch (std::exception& e) {
30059       {
30060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30061       };
30062     } catch (Dali::DaliException e) {
30063       {
30064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30065       };
30066     } catch (...) {
30067       {
30068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30069       };
30070     }
30071   }
30072
30073   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30074   return jresult;
30075 }
30076
30077
30078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30079   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30080
30081   arg1 = (Dali::GestureDetector *)jarg1;
30082   {
30083     try {
30084       delete arg1;
30085     } catch (std::out_of_range& e) {
30086       {
30087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30088       };
30089     } catch (std::exception& e) {
30090       {
30091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30092       };
30093     } catch (Dali::DaliException e) {
30094       {
30095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30096       };
30097     } catch (...) {
30098       {
30099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30100       };
30101     }
30102   }
30103
30104 }
30105
30106
30107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30108   void * jresult ;
30109   Dali::GestureDetector *arg1 = 0 ;
30110   Dali::GestureDetector *result = 0 ;
30111
30112   arg1 = (Dali::GestureDetector *)jarg1;
30113   if (!arg1) {
30114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30115     return 0;
30116   }
30117   {
30118     try {
30119       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30120     } catch (std::out_of_range& e) {
30121       {
30122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30123       };
30124     } catch (std::exception& e) {
30125       {
30126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30127       };
30128     } catch (Dali::DaliException e) {
30129       {
30130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30131       };
30132     } catch (...) {
30133       {
30134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30135       };
30136     }
30137   }
30138
30139   jresult = (void *)result;
30140   return jresult;
30141 }
30142
30143
30144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30145   void * jresult ;
30146   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30147   Dali::GestureDetector *arg2 = 0 ;
30148   Dali::GestureDetector *result = 0 ;
30149
30150   arg1 = (Dali::GestureDetector *)jarg1;
30151   arg2 = (Dali::GestureDetector *)jarg2;
30152   if (!arg2) {
30153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30154     return 0;
30155   }
30156   {
30157     try {
30158       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30159     } catch (std::out_of_range& e) {
30160       {
30161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30162       };
30163     } catch (std::exception& e) {
30164       {
30165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30166       };
30167     } catch (Dali::DaliException e) {
30168       {
30169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30170       };
30171     } catch (...) {
30172       {
30173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30174       };
30175     }
30176   }
30177
30178   jresult = (void *)result;
30179   return jresult;
30180 }
30181
30182
30183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30184   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30185   Dali::Actor arg2 ;
30186   Dali::Actor *argp2 ;
30187
30188   arg1 = (Dali::GestureDetector *)jarg1;
30189   argp2 = (Dali::Actor *)jarg2;
30190   if (!argp2) {
30191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30192     return ;
30193   }
30194   arg2 = *argp2;
30195   {
30196     try {
30197       (arg1)->Attach(arg2);
30198     } catch (std::out_of_range& e) {
30199       {
30200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30201       };
30202     } catch (std::exception& e) {
30203       {
30204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30205       };
30206     } catch (Dali::DaliException e) {
30207       {
30208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30209       };
30210     } catch (...) {
30211       {
30212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30213       };
30214     }
30215   }
30216
30217 }
30218
30219
30220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30221   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30222   Dali::Actor arg2 ;
30223   Dali::Actor *argp2 ;
30224
30225   arg1 = (Dali::GestureDetector *)jarg1;
30226   argp2 = (Dali::Actor *)jarg2;
30227   if (!argp2) {
30228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30229     return ;
30230   }
30231   arg2 = *argp2;
30232   {
30233     try {
30234       (arg1)->Detach(arg2);
30235     } catch (std::out_of_range& e) {
30236       {
30237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30238       };
30239     } catch (std::exception& e) {
30240       {
30241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30242       };
30243     } catch (Dali::DaliException e) {
30244       {
30245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30246       };
30247     } catch (...) {
30248       {
30249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30250       };
30251     }
30252   }
30253
30254 }
30255
30256
30257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30258   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30259
30260   arg1 = (Dali::GestureDetector *)jarg1;
30261   {
30262     try {
30263       (arg1)->DetachAll();
30264     } catch (std::out_of_range& e) {
30265       {
30266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30267       };
30268     } catch (std::exception& e) {
30269       {
30270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30271       };
30272     } catch (Dali::DaliException e) {
30273       {
30274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30275       };
30276     } catch (...) {
30277       {
30278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30279       };
30280     }
30281   }
30282
30283 }
30284
30285
30286 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30287   unsigned long jresult ;
30288   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30289   size_t result;
30290
30291   arg1 = (Dali::GestureDetector *)jarg1;
30292   {
30293     try {
30294       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30295     } catch (std::out_of_range& e) {
30296       {
30297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30298       };
30299     } catch (std::exception& e) {
30300       {
30301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30302       };
30303     } catch (Dali::DaliException e) {
30304       {
30305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30306       };
30307     } catch (...) {
30308       {
30309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30310       };
30311     }
30312   }
30313
30314   jresult = (unsigned long)result;
30315   return jresult;
30316 }
30317
30318
30319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30320   void * jresult ;
30321   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30322   size_t arg2 ;
30323   Dali::Actor result;
30324
30325   arg1 = (Dali::GestureDetector *)jarg1;
30326   arg2 = (size_t)jarg2;
30327   {
30328     try {
30329       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30330     } catch (std::out_of_range& e) {
30331       {
30332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30333       };
30334     } catch (std::exception& e) {
30335       {
30336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30337       };
30338     } catch (Dali::DaliException e) {
30339       {
30340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30341       };
30342     } catch (...) {
30343       {
30344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30345       };
30346     }
30347   }
30348
30349   jresult = new Dali::Actor((const Dali::Actor &)result);
30350   return jresult;
30351 }
30352
30353
30354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30355   void * jresult ;
30356   Dali::Gesture *arg1 = 0 ;
30357   Dali::Gesture *result = 0 ;
30358
30359   arg1 = (Dali::Gesture *)jarg1;
30360   if (!arg1) {
30361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30362     return 0;
30363   }
30364   {
30365     try {
30366       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30367     } catch (std::out_of_range& e) {
30368       {
30369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30370       };
30371     } catch (std::exception& e) {
30372       {
30373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30374       };
30375     } catch (Dali::DaliException e) {
30376       {
30377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30378       };
30379     } catch (...) {
30380       {
30381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30382       };
30383     }
30384   }
30385
30386   jresult = (void *)result;
30387   return jresult;
30388 }
30389
30390
30391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30392   void * jresult ;
30393   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30394   Dali::Gesture *arg2 = 0 ;
30395   Dali::Gesture *result = 0 ;
30396
30397   arg1 = (Dali::Gesture *)jarg1;
30398   arg2 = (Dali::Gesture *)jarg2;
30399   if (!arg2) {
30400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30401     return 0;
30402   }
30403   {
30404     try {
30405       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30406     } catch (std::out_of_range& e) {
30407       {
30408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30409       };
30410     } catch (std::exception& e) {
30411       {
30412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30413       };
30414     } catch (Dali::DaliException e) {
30415       {
30416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30417       };
30418     } catch (...) {
30419       {
30420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30421       };
30422     }
30423   }
30424
30425   jresult = (void *)result;
30426   return jresult;
30427 }
30428
30429
30430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30431   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30432
30433   arg1 = (Dali::Gesture *)jarg1;
30434   {
30435     try {
30436       delete arg1;
30437     } catch (std::out_of_range& e) {
30438       {
30439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30440       };
30441     } catch (std::exception& e) {
30442       {
30443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30444       };
30445     } catch (Dali::DaliException e) {
30446       {
30447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30448       };
30449     } catch (...) {
30450       {
30451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30452       };
30453     }
30454   }
30455
30456 }
30457
30458
30459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30460   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30461   Dali::Gesture::Type arg2 ;
30462
30463   arg1 = (Dali::Gesture *)jarg1;
30464   arg2 = (Dali::Gesture::Type)jarg2;
30465   if (arg1) (arg1)->type = arg2;
30466 }
30467
30468
30469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30470   int jresult ;
30471   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30472   Dali::Gesture::Type result;
30473
30474   arg1 = (Dali::Gesture *)jarg1;
30475   result = (Dali::Gesture::Type) ((arg1)->type);
30476   jresult = (int)result;
30477   return jresult;
30478 }
30479
30480
30481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30482   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30483   Dali::Gesture::State arg2 ;
30484
30485   arg1 = (Dali::Gesture *)jarg1;
30486   arg2 = (Dali::Gesture::State)jarg2;
30487   if (arg1) (arg1)->state = arg2;
30488 }
30489
30490
30491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30492   int jresult ;
30493   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30494   Dali::Gesture::State result;
30495
30496   arg1 = (Dali::Gesture *)jarg1;
30497   result = (Dali::Gesture::State) ((arg1)->state);
30498   jresult = (int)result;
30499   return jresult;
30500 }
30501
30502
30503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30504   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30505   unsigned int arg2 ;
30506
30507   arg1 = (Dali::Gesture *)jarg1;
30508   arg2 = (unsigned int)jarg2;
30509   if (arg1) (arg1)->time = arg2;
30510 }
30511
30512
30513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30514   unsigned int jresult ;
30515   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30516   unsigned int result;
30517
30518   arg1 = (Dali::Gesture *)jarg1;
30519   result = (unsigned int) ((arg1)->time);
30520   jresult = result;
30521   return jresult;
30522 }
30523
30524
30525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30526   void * jresult ;
30527   Dali::HoverEvent *result = 0 ;
30528
30529   {
30530     try {
30531       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30532     } catch (std::out_of_range& e) {
30533       {
30534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30535       };
30536     } catch (std::exception& e) {
30537       {
30538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30539       };
30540     } catch (Dali::DaliException e) {
30541       {
30542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30543       };
30544     } catch (...) {
30545       {
30546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30547       };
30548     }
30549   }
30550
30551   jresult = (void *)result;
30552   return jresult;
30553 }
30554
30555
30556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
30557   void * jresult ;
30558   Dali::HoverEvent *arg1 = 0 ;
30559   Dali::HoverEvent *result = 0 ;
30560
30561   arg1 = (Dali::HoverEvent *)jarg1;
30562   if (!arg1) {
30563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30564     return 0;
30565   }
30566   {
30567     try {
30568       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
30569     } catch (std::out_of_range& e) {
30570       {
30571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30572       };
30573     } catch (std::exception& e) {
30574       {
30575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30576       };
30577     } catch (Dali::DaliException e) {
30578       {
30579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30580       };
30581     } catch (...) {
30582       {
30583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30584       };
30585     }
30586   }
30587
30588   jresult = (void *)result;
30589   return jresult;
30590 }
30591
30592
30593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30594   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30595
30596   arg1 = (Dali::HoverEvent *)jarg1;
30597   {
30598     try {
30599       delete arg1;
30600     } catch (std::out_of_range& e) {
30601       {
30602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30603       };
30604     } catch (std::exception& e) {
30605       {
30606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30607       };
30608     } catch (Dali::DaliException e) {
30609       {
30610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30611       };
30612     } catch (...) {
30613       {
30614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30615       };
30616     }
30617   }
30618
30619 }
30620
30621
30622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
30623   void * jresult ;
30624   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30625   Dali::HoverEvent *arg2 = 0 ;
30626   Dali::HoverEvent *result = 0 ;
30627
30628   arg1 = (Dali::HoverEvent *)jarg1;
30629   arg2 = (Dali::HoverEvent *)jarg2;
30630   if (!arg2) {
30631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30632     return 0;
30633   }
30634   {
30635     try {
30636       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
30637     } catch (std::out_of_range& e) {
30638       {
30639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30640       };
30641     } catch (std::exception& e) {
30642       {
30643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30644       };
30645     } catch (Dali::DaliException e) {
30646       {
30647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30648       };
30649     } catch (...) {
30650       {
30651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30652       };
30653     }
30654   }
30655
30656   jresult = (void *)result;
30657   return jresult;
30658 }
30659
30660
30661 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
30662   unsigned long jresult ;
30663   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30664   unsigned long result;
30665
30666   arg1 = (Dali::HoverEvent *)jarg1;
30667   {
30668     try {
30669       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
30670     } catch (std::out_of_range& e) {
30671       {
30672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30673       };
30674     } catch (std::exception& e) {
30675       {
30676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30677       };
30678     } catch (Dali::DaliException e) {
30679       {
30680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30681       };
30682     } catch (...) {
30683       {
30684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30685       };
30686     }
30687   }
30688
30689   jresult = (unsigned long)result;
30690   return jresult;
30691 }
30692
30693
30694 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30695   unsigned long jresult ;
30696   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30697   std::size_t result;
30698
30699   arg1 = (Dali::HoverEvent *)jarg1;
30700   {
30701     try {
30702       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
30703     } catch (std::out_of_range& e) {
30704       {
30705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30706       };
30707     } catch (std::exception& e) {
30708       {
30709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30710       };
30711     } catch (Dali::DaliException e) {
30712       {
30713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30714       };
30715     } catch (...) {
30716       {
30717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30718       };
30719     }
30720   }
30721
30722   jresult = (unsigned long)result;
30723   return jresult;
30724 }
30725
30726
30727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
30728   int jresult ;
30729   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30730   std::size_t arg2 ;
30731   int32_t result;
30732
30733   arg1 = (Dali::HoverEvent *)jarg1;
30734   arg2 = (std::size_t)jarg2;
30735   {
30736     try {
30737       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
30738     } catch (std::out_of_range& e) {
30739       {
30740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30741       };
30742     } catch (std::exception& e) {
30743       {
30744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30745       };
30746     } catch (Dali::DaliException e) {
30747       {
30748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30749       };
30750     } catch (...) {
30751       {
30752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30753       };
30754     }
30755   }
30756
30757   jresult = result;
30758   return jresult;
30759 }
30760
30761
30762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
30763   int jresult ;
30764   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30765   std::size_t arg2 ;
30766   Dali::PointState::Type result;
30767
30768   arg1 = (Dali::HoverEvent *)jarg1;
30769   arg2 = (std::size_t)jarg2;
30770   {
30771     try {
30772       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
30773     } catch (std::out_of_range& e) {
30774       {
30775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30776       };
30777     } catch (std::exception& e) {
30778       {
30779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30780       };
30781     } catch (Dali::DaliException e) {
30782       {
30783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30784       };
30785     } catch (...) {
30786       {
30787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30788       };
30789     }
30790   }
30791
30792   jresult = (int)result;
30793   return jresult;
30794 }
30795
30796
30797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
30798   void * jresult ;
30799   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30800   std::size_t arg2 ;
30801   Dali::Actor result;
30802
30803   arg1 = (Dali::HoverEvent *)jarg1;
30804   arg2 = (std::size_t)jarg2;
30805   {
30806     try {
30807       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
30808     } catch (std::out_of_range& e) {
30809       {
30810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30811       };
30812     } catch (std::exception& e) {
30813       {
30814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30815       };
30816     } catch (Dali::DaliException e) {
30817       {
30818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30819       };
30820     } catch (...) {
30821       {
30822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30823       };
30824     }
30825   }
30826
30827   jresult = new Dali::Actor((const Dali::Actor &)result);
30828   return jresult;
30829 }
30830
30831
30832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30833   void * jresult ;
30834   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30835   std::size_t arg2 ;
30836   Dali::Vector2 *result = 0 ;
30837
30838   arg1 = (Dali::HoverEvent *)jarg1;
30839   arg2 = (std::size_t)jarg2;
30840   {
30841     try {
30842       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
30843     } catch (std::out_of_range& e) {
30844       {
30845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30846       };
30847     } catch (std::exception& e) {
30848       {
30849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30850       };
30851     } catch (Dali::DaliException e) {
30852       {
30853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30854       };
30855     } catch (...) {
30856       {
30857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30858       };
30859     }
30860   }
30861
30862   jresult = (void *)result;
30863   return jresult;
30864 }
30865
30866
30867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30868   void * jresult ;
30869   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30870   std::size_t arg2 ;
30871   Dali::Vector2 *result = 0 ;
30872
30873   arg1 = (Dali::HoverEvent *)jarg1;
30874   arg2 = (std::size_t)jarg2;
30875   {
30876     try {
30877       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
30878     } catch (std::out_of_range& e) {
30879       {
30880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30881       };
30882     } catch (std::exception& e) {
30883       {
30884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30885       };
30886     } catch (Dali::DaliException e) {
30887       {
30888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30889       };
30890     } catch (...) {
30891       {
30892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30893       };
30894     }
30895   }
30896
30897   jresult = (void *)result;
30898   return jresult;
30899 }
30900
30901
30902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30903   void * jresult ;
30904   Dali::KeyEvent *result = 0 ;
30905
30906   {
30907     try {
30908       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30909     } catch (std::out_of_range& e) {
30910       {
30911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30912       };
30913     } catch (std::exception& e) {
30914       {
30915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30916       };
30917     } catch (Dali::DaliException e) {
30918       {
30919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30920       };
30921     } catch (...) {
30922       {
30923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30924       };
30925     }
30926   }
30927
30928   jresult = (void *)result;
30929   return jresult;
30930 }
30931
30932
30933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30934   void * jresult ;
30935   std::string *arg1 = 0 ;
30936   std::string *arg2 = 0 ;
30937   int arg3 ;
30938   int arg4 ;
30939   unsigned long arg5 ;
30940   Dali::KeyEvent::State *arg6 = 0 ;
30941   Dali::KeyEvent::State temp6 ;
30942   Dali::KeyEvent *result = 0 ;
30943
30944   if (!jarg1) {
30945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30946     return 0;
30947   }
30948   std::string arg1_str(jarg1);
30949   arg1 = &arg1_str;
30950   if (!jarg2) {
30951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30952     return 0;
30953   }
30954   std::string arg2_str(jarg2);
30955   arg2 = &arg2_str;
30956   arg3 = (int)jarg3;
30957   arg4 = (int)jarg4;
30958   arg5 = (unsigned long)jarg5;
30959   temp6 = (Dali::KeyEvent::State)jarg6;
30960   arg6 = &temp6;
30961   {
30962     try {
30963       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30964     } catch (std::out_of_range& e) {
30965       {
30966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30967       };
30968     } catch (std::exception& e) {
30969       {
30970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30971       };
30972     } catch (Dali::DaliException e) {
30973       {
30974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30975       };
30976     } catch (...) {
30977       {
30978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30979       };
30980     }
30981   }
30982
30983   jresult = (void *)result;
30984
30985   //argout typemap for const std::string&
30986
30987
30988   //argout typemap for const std::string&
30989
30990   return jresult;
30991 }
30992
30993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30994   void * jresult ;
30995   Dali::KeyEvent *arg1 = 0 ;
30996   Dali::KeyEvent *result = 0 ;
30997
30998   arg1 = (Dali::KeyEvent *)jarg1;
30999   if (!arg1) {
31000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31001     return 0;
31002   }
31003   {
31004     try {
31005       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31006     } catch (std::out_of_range& e) {
31007       {
31008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31009       };
31010     } catch (std::exception& e) {
31011       {
31012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31013       };
31014     } catch (Dali::DaliException e) {
31015       {
31016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31017       };
31018     } catch (...) {
31019       {
31020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31021       };
31022     }
31023   }
31024
31025   jresult = (void *)result;
31026   return jresult;
31027 }
31028
31029
31030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31031   void * jresult ;
31032   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31033   Dali::KeyEvent *arg2 = 0 ;
31034   Dali::KeyEvent *result = 0 ;
31035
31036   arg1 = (Dali::KeyEvent *)jarg1;
31037   arg2 = (Dali::KeyEvent *)jarg2;
31038   if (!arg2) {
31039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31040     return 0;
31041   }
31042   {
31043     try {
31044       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31045     } catch (std::out_of_range& e) {
31046       {
31047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31048       };
31049     } catch (std::exception& e) {
31050       {
31051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31052       };
31053     } catch (Dali::DaliException e) {
31054       {
31055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31056       };
31057     } catch (...) {
31058       {
31059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31060       };
31061     }
31062   }
31063
31064   jresult = (void *)result;
31065   return jresult;
31066 }
31067
31068
31069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31070   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31071
31072   arg1 = (Dali::KeyEvent *)jarg1;
31073   {
31074     try {
31075       delete arg1;
31076     } catch (std::out_of_range& e) {
31077       {
31078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31079       };
31080     } catch (std::exception& e) {
31081       {
31082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31083       };
31084     } catch (Dali::DaliException e) {
31085       {
31086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31087       };
31088     } catch (...) {
31089       {
31090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31091       };
31092     }
31093   }
31094
31095 }
31096
31097
31098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31099   unsigned int jresult ;
31100   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31101   bool result;
31102
31103   arg1 = (Dali::KeyEvent *)jarg1;
31104   {
31105     try {
31106       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31107     } catch (std::out_of_range& e) {
31108       {
31109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31110       };
31111     } catch (std::exception& e) {
31112       {
31113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31114       };
31115     } catch (Dali::DaliException e) {
31116       {
31117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31118       };
31119     } catch (...) {
31120       {
31121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31122       };
31123     }
31124   }
31125
31126   jresult = result;
31127   return jresult;
31128 }
31129
31130
31131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31132   unsigned int jresult ;
31133   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31134   bool result;
31135
31136   arg1 = (Dali::KeyEvent *)jarg1;
31137   {
31138     try {
31139       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31140     } catch (std::out_of_range& e) {
31141       {
31142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31143       };
31144     } catch (std::exception& e) {
31145       {
31146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31147       };
31148     } catch (Dali::DaliException e) {
31149       {
31150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31151       };
31152     } catch (...) {
31153       {
31154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31155       };
31156     }
31157   }
31158
31159   jresult = result;
31160   return jresult;
31161 }
31162
31163
31164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31165   unsigned int jresult ;
31166   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31167   bool result;
31168
31169   arg1 = (Dali::KeyEvent *)jarg1;
31170   {
31171     try {
31172       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31173     } catch (std::out_of_range& e) {
31174       {
31175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31176       };
31177     } catch (std::exception& e) {
31178       {
31179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31180       };
31181     } catch (Dali::DaliException e) {
31182       {
31183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31184       };
31185     } catch (...) {
31186       {
31187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31188       };
31189     }
31190   }
31191
31192   jresult = result;
31193   return jresult;
31194 }
31195
31196
31197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31198   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31199   std::string *arg2 = 0 ;
31200
31201   arg1 = (Dali::KeyEvent *)jarg1;
31202   if (!jarg2) {
31203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31204     return ;
31205   }
31206   std::string arg2_str(jarg2);
31207   arg2 = &arg2_str;
31208   if (arg1) (arg1)->keyPressedName = *arg2;
31209
31210   //argout typemap for const std::string&
31211
31212 }
31213
31214
31215 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31216   char * jresult ;
31217
31218   if( jarg1 == NULL )
31219   {
31220     jresult = SWIG_csharp_string_callback( "" );
31221   }
31222   else
31223   {
31224     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31225     std::string *result = 0;
31226
31227     arg1 = ( Dali::KeyEvent * )jarg1;
31228     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31229     jresult = SWIG_csharp_string_callback( result->c_str() );
31230   }
31231
31232   return jresult;
31233 }
31234
31235
31236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31237   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31238   std::string *arg2 = 0 ;
31239
31240   arg1 = (Dali::KeyEvent *)jarg1;
31241   if (!jarg2) {
31242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31243     return ;
31244   }
31245   std::string arg2_str(jarg2);
31246   arg2 = &arg2_str;
31247   if (arg1) (arg1)->keyPressed = *arg2;
31248
31249   //argout typemap for const std::string&
31250
31251 }
31252
31253
31254 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31255   char * jresult ;
31256   if( NULL == jarg1 )
31257   {
31258     jresult = SWIG_csharp_string_callback( "" );
31259   }
31260   else
31261   {
31262     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31263     std::string *result = 0;
31264
31265     arg1 = ( Dali::KeyEvent * )jarg1;
31266     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31267     jresult = SWIG_csharp_string_callback( result->c_str() );
31268   }
31269   return jresult;
31270 }
31271
31272
31273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31274   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31275   int arg2 ;
31276
31277   arg1 = (Dali::KeyEvent *)jarg1;
31278   arg2 = (int)jarg2;
31279   if (arg1) (arg1)->keyCode = arg2;
31280 }
31281
31282
31283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31284   int jresult ;
31285   if( NULL == jarg1 )
31286   {
31287     jresult = -1;
31288   }
31289   else
31290   {
31291     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31292     int result;
31293
31294     arg1 = ( Dali::KeyEvent * )jarg1;
31295     result = (int)( ( arg1 )->keyCode );
31296     jresult = result;
31297   }
31298   return jresult;
31299 }
31300
31301
31302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31303   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31304   int arg2 ;
31305
31306   arg1 = (Dali::KeyEvent *)jarg1;
31307   arg2 = (int)jarg2;
31308   if (arg1) (arg1)->keyModifier = arg2;
31309 }
31310
31311
31312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31313   int jresult ;
31314   if( jarg1 == NULL )
31315   {
31316     jresult = -1;
31317   }
31318   else
31319   {
31320     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31321     int result;
31322
31323     arg1 = ( Dali::KeyEvent * )jarg1;
31324     result = (int)( ( arg1 )->keyModifier );
31325     jresult = result;
31326   }
31327   return jresult;
31328 }
31329
31330
31331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31332   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31333   unsigned long arg2 ;
31334
31335   arg1 = (Dali::KeyEvent *)jarg1;
31336   arg2 = (unsigned long)jarg2;
31337   if (arg1) (arg1)->time = arg2;
31338 }
31339
31340
31341 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31342   unsigned long jresult ;
31343   if( jarg1 == NULL )
31344   {
31345     jresult = 0;
31346   }
31347   else
31348   {
31349     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31350     unsigned long result;
31351
31352     arg1 = ( Dali::KeyEvent * )jarg1;
31353     result = (unsigned long)( ( arg1 )->time );
31354     jresult = (unsigned long)result;
31355   }
31356   return jresult;
31357 }
31358
31359
31360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31361   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31362   Dali::KeyEvent::State arg2 ;
31363
31364   arg1 = (Dali::KeyEvent *)jarg1;
31365   arg2 = (Dali::KeyEvent::State)jarg2;
31366   if (arg1) (arg1)->state = arg2;
31367 }
31368
31369
31370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31371   int jresult ;
31372   if( jarg1 == NULL )
31373   {
31374     jresult = -1;
31375   }
31376   else
31377   {
31378     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31379     Dali::KeyEvent::State result;
31380
31381     arg1 = ( Dali::KeyEvent * )jarg1;
31382     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31383     jresult = (int)result;
31384   }
31385   return jresult;
31386 }
31387
31388 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31389   char * jresult ;
31390   std::string result;
31391   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31392
31393   arg1 = (Dali::KeyEvent *)jarg1;
31394   if (!arg1) {
31395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31396     return 0;
31397   }
31398   {
31399     try {
31400       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31401     } catch (std::out_of_range& e) {
31402       {
31403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31404       };
31405     } catch (std::exception& e) {
31406       {
31407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31408       };
31409     } catch (Dali::DaliException e) {
31410       {
31411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31412       };
31413     } catch (...) {
31414       {
31415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31416       };
31417     }
31418
31419   }
31420
31421   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31422   return jresult;
31423 }
31424
31425
31426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31427   void * jresult ;
31428   Dali::LongPressGestureDetector *result = 0 ;
31429
31430   {
31431     try {
31432       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31433     } catch (std::out_of_range& e) {
31434       {
31435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31436       };
31437     } catch (std::exception& e) {
31438       {
31439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31440       };
31441     } catch (Dali::DaliException e) {
31442       {
31443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31444       };
31445     } catch (...) {
31446       {
31447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31448       };
31449     }
31450   }
31451
31452   jresult = (void *)result;
31453   return jresult;
31454 }
31455
31456
31457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31458   void * jresult ;
31459   Dali::LongPressGestureDetector result;
31460
31461   {
31462     try {
31463       result = Dali::LongPressGestureDetector::New();
31464     } catch (std::out_of_range& e) {
31465       {
31466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31467       };
31468     } catch (std::exception& e) {
31469       {
31470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31471       };
31472     } catch (Dali::DaliException e) {
31473       {
31474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31475       };
31476     } catch (...) {
31477       {
31478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31479       };
31480     }
31481   }
31482
31483   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31484   return jresult;
31485 }
31486
31487
31488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31489   void * jresult ;
31490   unsigned int arg1 ;
31491   Dali::LongPressGestureDetector result;
31492
31493   arg1 = (unsigned int)jarg1;
31494   {
31495     try {
31496       result = Dali::LongPressGestureDetector::New(arg1);
31497     } catch (std::out_of_range& e) {
31498       {
31499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31500       };
31501     } catch (std::exception& e) {
31502       {
31503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31504       };
31505     } catch (Dali::DaliException e) {
31506       {
31507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31508       };
31509     } catch (...) {
31510       {
31511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31512       };
31513     }
31514   }
31515
31516   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31517   return jresult;
31518 }
31519
31520
31521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31522   void * jresult ;
31523   unsigned int arg1 ;
31524   unsigned int arg2 ;
31525   Dali::LongPressGestureDetector result;
31526
31527   arg1 = (unsigned int)jarg1;
31528   arg2 = (unsigned int)jarg2;
31529   {
31530     try {
31531       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31532     } catch (std::out_of_range& e) {
31533       {
31534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31535       };
31536     } catch (std::exception& e) {
31537       {
31538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31539       };
31540     } catch (Dali::DaliException e) {
31541       {
31542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31543       };
31544     } catch (...) {
31545       {
31546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31547       };
31548     }
31549   }
31550
31551   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31552   return jresult;
31553 }
31554
31555
31556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31557   void * jresult ;
31558   Dali::BaseHandle arg1 ;
31559   Dali::BaseHandle *argp1 ;
31560   Dali::LongPressGestureDetector result;
31561
31562   argp1 = (Dali::BaseHandle *)jarg1;
31563   if (!argp1) {
31564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31565     return 0;
31566   }
31567   arg1 = *argp1;
31568   {
31569     try {
31570       result = Dali::LongPressGestureDetector::DownCast(arg1);
31571     } catch (std::out_of_range& e) {
31572       {
31573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31574       };
31575     } catch (std::exception& e) {
31576       {
31577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31578       };
31579     } catch (Dali::DaliException e) {
31580       {
31581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31582       };
31583     } catch (...) {
31584       {
31585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31586       };
31587     }
31588   }
31589
31590   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31591   return jresult;
31592 }
31593
31594
31595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31596   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31597
31598   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31599   {
31600     try {
31601       delete arg1;
31602     } catch (std::out_of_range& e) {
31603       {
31604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31605       };
31606     } catch (std::exception& e) {
31607       {
31608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31609       };
31610     } catch (Dali::DaliException e) {
31611       {
31612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31613       };
31614     } catch (...) {
31615       {
31616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31617       };
31618     }
31619   }
31620
31621 }
31622
31623
31624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31625   void * jresult ;
31626   Dali::LongPressGestureDetector *arg1 = 0 ;
31627   Dali::LongPressGestureDetector *result = 0 ;
31628
31629   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31630   if (!arg1) {
31631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31632     return 0;
31633   }
31634   {
31635     try {
31636       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31637     } catch (std::out_of_range& e) {
31638       {
31639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31640       };
31641     } catch (std::exception& e) {
31642       {
31643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31644       };
31645     } catch (Dali::DaliException e) {
31646       {
31647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31648       };
31649     } catch (...) {
31650       {
31651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31652       };
31653     }
31654   }
31655
31656   jresult = (void *)result;
31657   return jresult;
31658 }
31659
31660
31661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31662   void * jresult ;
31663   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31664   Dali::LongPressGestureDetector *arg2 = 0 ;
31665   Dali::LongPressGestureDetector *result = 0 ;
31666
31667   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31668   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31669   if (!arg2) {
31670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31671     return 0;
31672   }
31673   {
31674     try {
31675       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31676     } catch (std::out_of_range& e) {
31677       {
31678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31679       };
31680     } catch (std::exception& e) {
31681       {
31682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31683       };
31684     } catch (Dali::DaliException e) {
31685       {
31686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31687       };
31688     } catch (...) {
31689       {
31690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31691       };
31692     }
31693   }
31694
31695   jresult = (void *)result;
31696   return jresult;
31697 }
31698
31699
31700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31701   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31702   unsigned int arg2 ;
31703
31704   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31705   arg2 = (unsigned int)jarg2;
31706   {
31707     try {
31708       (arg1)->SetTouchesRequired(arg2);
31709     } catch (std::out_of_range& e) {
31710       {
31711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31712       };
31713     } catch (std::exception& e) {
31714       {
31715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31716       };
31717     } catch (Dali::DaliException e) {
31718       {
31719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31720       };
31721     } catch (...) {
31722       {
31723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31724       };
31725     }
31726   }
31727
31728 }
31729
31730
31731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31732   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31733   unsigned int arg2 ;
31734   unsigned int arg3 ;
31735
31736   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31737   arg2 = (unsigned int)jarg2;
31738   arg3 = (unsigned int)jarg3;
31739   {
31740     try {
31741       (arg1)->SetTouchesRequired(arg2,arg3);
31742     } catch (std::out_of_range& e) {
31743       {
31744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31745       };
31746     } catch (std::exception& e) {
31747       {
31748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31749       };
31750     } catch (Dali::DaliException e) {
31751       {
31752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31753       };
31754     } catch (...) {
31755       {
31756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31757       };
31758     }
31759   }
31760
31761 }
31762
31763
31764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31765   unsigned int jresult ;
31766   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31767   unsigned int result;
31768
31769   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31770   {
31771     try {
31772       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31773     } catch (std::out_of_range& e) {
31774       {
31775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31776       };
31777     } catch (std::exception& e) {
31778       {
31779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31780       };
31781     } catch (Dali::DaliException e) {
31782       {
31783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31784       };
31785     } catch (...) {
31786       {
31787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31788       };
31789     }
31790   }
31791
31792   jresult = result;
31793   return jresult;
31794 }
31795
31796
31797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31798   unsigned int jresult ;
31799   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31800   unsigned int result;
31801
31802   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31803   {
31804     try {
31805       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31806     } catch (std::out_of_range& e) {
31807       {
31808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31809       };
31810     } catch (std::exception& e) {
31811       {
31812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31813       };
31814     } catch (Dali::DaliException e) {
31815       {
31816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31817       };
31818     } catch (...) {
31819       {
31820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31821       };
31822     }
31823   }
31824
31825   jresult = result;
31826   return jresult;
31827 }
31828
31829
31830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31831   void * jresult ;
31832   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31833   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31834
31835   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31836   {
31837     try {
31838       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31839     } catch (std::out_of_range& e) {
31840       {
31841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31842       };
31843     } catch (std::exception& e) {
31844       {
31845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31846       };
31847     } catch (Dali::DaliException e) {
31848       {
31849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31850       };
31851     } catch (...) {
31852       {
31853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31854       };
31855     }
31856   }
31857
31858   jresult = (void *)result;
31859   return jresult;
31860 }
31861
31862
31863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31864   void * jresult ;
31865   Dali::Gesture::State arg1 ;
31866   Dali::LongPressGesture *result = 0 ;
31867
31868   arg1 = (Dali::Gesture::State)jarg1;
31869   {
31870     try {
31871       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31872     } catch (std::out_of_range& e) {
31873       {
31874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31875       };
31876     } catch (std::exception& e) {
31877       {
31878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31879       };
31880     } catch (Dali::DaliException e) {
31881       {
31882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31883       };
31884     } catch (...) {
31885       {
31886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31887       };
31888     }
31889   }
31890
31891   jresult = (void *)result;
31892   return jresult;
31893 }
31894
31895
31896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31897   void * jresult ;
31898   Dali::LongPressGesture *arg1 = 0 ;
31899   Dali::LongPressGesture *result = 0 ;
31900
31901   arg1 = (Dali::LongPressGesture *)jarg1;
31902   if (!arg1) {
31903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31904     return 0;
31905   }
31906   {
31907     try {
31908       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31909     } catch (std::out_of_range& e) {
31910       {
31911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31912       };
31913     } catch (std::exception& e) {
31914       {
31915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31916       };
31917     } catch (Dali::DaliException e) {
31918       {
31919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31920       };
31921     } catch (...) {
31922       {
31923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31924       };
31925     }
31926   }
31927
31928   jresult = (void *)result;
31929   return jresult;
31930 }
31931
31932
31933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31934   void * jresult ;
31935   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31936   Dali::LongPressGesture *arg2 = 0 ;
31937   Dali::LongPressGesture *result = 0 ;
31938
31939   arg1 = (Dali::LongPressGesture *)jarg1;
31940   arg2 = (Dali::LongPressGesture *)jarg2;
31941   if (!arg2) {
31942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31943     return 0;
31944   }
31945   {
31946     try {
31947       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31948     } catch (std::out_of_range& e) {
31949       {
31950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31951       };
31952     } catch (std::exception& e) {
31953       {
31954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31955       };
31956     } catch (Dali::DaliException e) {
31957       {
31958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31959       };
31960     } catch (...) {
31961       {
31962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31963       };
31964     }
31965   }
31966
31967   jresult = (void *)result;
31968   return jresult;
31969 }
31970
31971
31972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31973   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31974
31975   arg1 = (Dali::LongPressGesture *)jarg1;
31976   {
31977     try {
31978       delete arg1;
31979     } catch (std::out_of_range& e) {
31980       {
31981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31982       };
31983     } catch (std::exception& e) {
31984       {
31985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31986       };
31987     } catch (Dali::DaliException e) {
31988       {
31989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31990       };
31991     } catch (...) {
31992       {
31993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31994       };
31995     }
31996   }
31997
31998 }
31999
32000
32001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32002   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32003   unsigned int arg2 ;
32004
32005   arg1 = (Dali::LongPressGesture *)jarg1;
32006   arg2 = (unsigned int)jarg2;
32007   if (arg1) (arg1)->numberOfTouches = arg2;
32008 }
32009
32010
32011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32012   unsigned int jresult ;
32013   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32014   unsigned int result;
32015
32016   arg1 = (Dali::LongPressGesture *)jarg1;
32017   result = (unsigned int) ((arg1)->numberOfTouches);
32018   jresult = result;
32019   return jresult;
32020 }
32021
32022
32023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32024   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32025   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32026
32027   arg1 = (Dali::LongPressGesture *)jarg1;
32028   arg2 = (Dali::Vector2 *)jarg2;
32029   if (arg1) (arg1)->screenPoint = *arg2;
32030 }
32031
32032
32033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32034   void * jresult ;
32035   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32036   Dali::Vector2 *result = 0 ;
32037
32038   arg1 = (Dali::LongPressGesture *)jarg1;
32039   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32040   jresult = (void *)result;
32041   return jresult;
32042 }
32043
32044
32045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32046   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32047   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32048
32049   arg1 = (Dali::LongPressGesture *)jarg1;
32050   arg2 = (Dali::Vector2 *)jarg2;
32051   if (arg1) (arg1)->localPoint = *arg2;
32052 }
32053
32054
32055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32056   void * jresult ;
32057   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32058   Dali::Vector2 *result = 0 ;
32059
32060   arg1 = (Dali::LongPressGesture *)jarg1;
32061   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32062   jresult = (void *)result;
32063   return jresult;
32064 }
32065
32066
32067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32068   void * jresult ;
32069   Dali::WheelEvent *result = 0 ;
32070
32071   {
32072     try {
32073       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32074     } catch (std::out_of_range& e) {
32075       {
32076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32077       };
32078     } catch (std::exception& e) {
32079       {
32080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32081       };
32082     } catch (Dali::DaliException e) {
32083       {
32084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32085       };
32086     } catch (...) {
32087       {
32088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32089       };
32090     }
32091   }
32092
32093   jresult = (void *)result;
32094   return jresult;
32095 }
32096
32097
32098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
32099   void * jresult ;
32100   Dali::WheelEvent *arg1 = 0 ;
32101   Dali::WheelEvent *result = 0 ;
32102
32103   arg1 = (Dali::WheelEvent *)jarg1;
32104   if (!arg1) {
32105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32106     return 0;
32107   }
32108   {
32109     try {
32110       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
32111     } catch (std::out_of_range& e) {
32112       {
32113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32114       };
32115     } catch (std::exception& e) {
32116       {
32117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32118       };
32119     } catch (Dali::DaliException e) {
32120       {
32121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32122       };
32123     } catch (...) {
32124       {
32125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32126       };
32127     }
32128   }
32129
32130   jresult = (void *)result;
32131   return jresult;
32132 }
32133
32134
32135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
32136   void * jresult ;
32137   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32138   Dali::WheelEvent *arg2 = 0 ;
32139   Dali::WheelEvent *result = 0 ;
32140
32141   arg1 = (Dali::WheelEvent *)jarg1;
32142   arg2 = (Dali::WheelEvent *)jarg2;
32143   if (!arg2) {
32144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32145     return 0;
32146   }
32147   {
32148     try {
32149       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
32150     } catch (std::out_of_range& e) {
32151       {
32152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32153       };
32154     } catch (std::exception& e) {
32155       {
32156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32157       };
32158     } catch (Dali::DaliException e) {
32159       {
32160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32161       };
32162     } catch (...) {
32163       {
32164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32165       };
32166     }
32167   }
32168
32169   jresult = (void *)result;
32170   return jresult;
32171 }
32172
32173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32174   void * jresult ;
32175   Dali::WheelEvent::Type arg1 ;
32176   int arg2 ;
32177   unsigned int arg3 ;
32178   Dali::Vector2 arg4 ;
32179   int arg5 ;
32180   unsigned int arg6 ;
32181   Dali::Vector2 *argp4 ;
32182   Dali::WheelEvent result;
32183
32184   arg1 = (Dali::WheelEvent::Type)jarg1;
32185   arg2 = (int)jarg2;
32186   arg3 = (unsigned int)jarg3;
32187   argp4 = (Dali::Vector2 *)jarg4;
32188   if (!argp4) {
32189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32190     return 0;
32191   }
32192   arg4 = *argp4;
32193   arg5 = (int)jarg5;
32194   arg6 = (unsigned int)jarg6;
32195   {
32196     try {
32197       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
32198     } catch (std::out_of_range& e) {
32199       {
32200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32201       };
32202     } catch (std::exception& e) {
32203       {
32204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32205       };
32206     } catch (Dali::DaliException e) {
32207       {
32208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32209       };
32210     } catch (...) {
32211       {
32212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32213       };
32214     }
32215   }
32216
32217   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
32218   return jresult;
32219 }
32220
32221
32222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32223   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32224
32225   arg1 = (Dali::WheelEvent *)jarg1;
32226   {
32227     try {
32228       delete arg1;
32229     } catch (std::out_of_range& e) {
32230       {
32231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32232       };
32233     } catch (std::exception& e) {
32234       {
32235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32236       };
32237     } catch (Dali::DaliException e) {
32238       {
32239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32240       };
32241     } catch (...) {
32242       {
32243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32244       };
32245     }
32246   }
32247
32248 }
32249
32250
32251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32252   unsigned int jresult ;
32253   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32254   bool result;
32255
32256   arg1 = (Dali::WheelEvent *)jarg1;
32257   {
32258     try {
32259       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32260     } catch (std::out_of_range& e) {
32261       {
32262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32263       };
32264     } catch (std::exception& e) {
32265       {
32266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32267       };
32268     } catch (Dali::DaliException e) {
32269       {
32270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32271       };
32272     } catch (...) {
32273       {
32274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32275       };
32276     }
32277   }
32278
32279   jresult = result;
32280   return jresult;
32281 }
32282
32283
32284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32285   unsigned int jresult ;
32286   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32287   bool result;
32288
32289   arg1 = (Dali::WheelEvent *)jarg1;
32290   {
32291     try {
32292       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32293     } catch (std::out_of_range& e) {
32294       {
32295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32296       };
32297     } catch (std::exception& e) {
32298       {
32299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32300       };
32301     } catch (Dali::DaliException e) {
32302       {
32303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32304       };
32305     } catch (...) {
32306       {
32307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32308       };
32309     }
32310   }
32311
32312   jresult = result;
32313   return jresult;
32314 }
32315
32316
32317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32318   unsigned int jresult ;
32319   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32320   bool result;
32321
32322   arg1 = (Dali::WheelEvent *)jarg1;
32323   {
32324     try {
32325       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32326     } catch (std::out_of_range& e) {
32327       {
32328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32329       };
32330     } catch (std::exception& e) {
32331       {
32332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32333       };
32334     } catch (Dali::DaliException e) {
32335       {
32336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32337       };
32338     } catch (...) {
32339       {
32340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32341       };
32342     }
32343   }
32344
32345   jresult = result;
32346   return jresult;
32347 }
32348
32349
32350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32351   int jresult ;
32352   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32353   Dali::WheelEvent::Type result;
32354
32355   arg1 = (Dali::WheelEvent *)jarg1;
32356   {
32357     try {
32358       result = ((Dali::WheelEvent const *)arg1)->GetType();
32359     } catch (std::out_of_range& e) {
32360       {
32361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32362       };
32363     } catch (std::exception& e) {
32364       {
32365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32366       };
32367     } catch (Dali::DaliException e) {
32368       {
32369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32370       };
32371     } catch (...) {
32372       {
32373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32374       };
32375     }
32376   }
32377
32378   jresult = (int)result;
32379   return jresult;
32380 }
32381
32382
32383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32384   int jresult ;
32385   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32386   int result;
32387
32388   arg1 = (Dali::WheelEvent *)jarg1;
32389   {
32390     try {
32391       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
32392     } catch (std::out_of_range& e) {
32393       {
32394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32395       };
32396     } catch (std::exception& e) {
32397       {
32398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32399       };
32400     } catch (Dali::DaliException e) {
32401       {
32402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32403       };
32404     } catch (...) {
32405       {
32406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32407       };
32408     }
32409   }
32410
32411   jresult = result;
32412   return jresult;
32413 }
32414
32415
32416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32417   unsigned int jresult ;
32418   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32419   unsigned int result;
32420
32421   arg1 = (Dali::WheelEvent *)jarg1;
32422   {
32423     try {
32424       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
32425     } catch (std::out_of_range& e) {
32426       {
32427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32428       };
32429     } catch (std::exception& e) {
32430       {
32431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32432       };
32433     } catch (Dali::DaliException e) {
32434       {
32435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32436       };
32437     } catch (...) {
32438       {
32439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32440       };
32441     }
32442   }
32443
32444   jresult = result;
32445   return jresult;
32446 }
32447
32448
32449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32450   void * jresult ;
32451   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32452   Dali::Vector2 *result = 0 ;
32453
32454   arg1 = (Dali::WheelEvent *)jarg1;
32455   {
32456     try {
32457       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
32458     } catch (std::out_of_range& e) {
32459       {
32460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32461       };
32462     } catch (std::exception& e) {
32463       {
32464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32465       };
32466     } catch (Dali::DaliException e) {
32467       {
32468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32469       };
32470     } catch (...) {
32471       {
32472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32473       };
32474     }
32475   }
32476
32477   jresult = (void *)result;
32478   return jresult;
32479 }
32480
32481
32482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
32483   int jresult ;
32484   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32485   int result;
32486
32487   arg1 = (Dali::WheelEvent *)jarg1;
32488   {
32489     try {
32490       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
32491     } catch (std::out_of_range& e) {
32492       {
32493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32494       };
32495     } catch (std::exception& e) {
32496       {
32497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32498       };
32499     } catch (Dali::DaliException e) {
32500       {
32501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32502       };
32503     } catch (...) {
32504       {
32505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32506       };
32507     }
32508   }
32509
32510   jresult = result;
32511   return jresult;
32512 }
32513
32514
32515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32516   unsigned int jresult ;
32517   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32518   unsigned int result;
32519
32520   arg1 = (Dali::WheelEvent *)jarg1;
32521   {
32522     try {
32523       result = ((Dali::WheelEvent const *)arg1)->GetTime();
32524     } catch (std::out_of_range& e) {
32525       {
32526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32527       };
32528     } catch (std::exception& e) {
32529       {
32530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32531       };
32532     } catch (Dali::DaliException e) {
32533       {
32534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32535       };
32536     } catch (...) {
32537       {
32538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32539       };
32540     }
32541   }
32542
32543   jresult = result;
32544   return jresult;
32545 }
32546
32547 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32548   char * jresult ;
32549   Dali::KeyEvent *arg1 = 0 ;
32550   std::string result;
32551
32552   arg1 = (Dali::KeyEvent *)jarg1;
32553   if (!arg1) {
32554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32555     return 0;
32556   }
32557   {
32558     try {
32559       result = arg1->GetDeviceName();
32560     } catch (std::out_of_range& e) {
32561       {
32562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32563       };
32564     } catch (std::exception& e) {
32565       {
32566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32567       };
32568     } catch (Dali::DaliException e) {
32569       {
32570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32571       };
32572     } catch (...) {
32573       {
32574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32575       };
32576     }
32577   }
32578
32579   jresult = SWIG_csharp_string_callback((&result)->c_str());
32580   return jresult;
32581 }
32582
32583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32584   int jresult ;
32585   Dali::KeyEvent *arg1 = 0 ;
32586   Dali::Device::Class::Type result;
32587
32588   arg1 = (Dali::KeyEvent *)jarg1;
32589   if (!arg1) {
32590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32591     return 0;
32592   }
32593   {
32594     try {
32595       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32596     } catch (std::out_of_range& e) {
32597       {
32598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32599       };
32600     } catch (std::exception& e) {
32601       {
32602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32603       };
32604     } catch (Dali::DaliException e) {
32605       {
32606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32607       };
32608     } catch (...) {
32609       {
32610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32611       };
32612     }
32613   }
32614
32615   jresult = (int)result;
32616   return jresult;
32617 }
32618
32619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32620   int jresult ;
32621   Dali::KeyEvent *arg1 = 0 ;
32622   Dali::Device::Subclass::Type result;
32623
32624   arg1 = (Dali::KeyEvent *)jarg1;
32625   if (!arg1) {
32626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32627     return 0;
32628   }
32629   {
32630     try {
32631       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32632     } catch (std::out_of_range& e) {
32633       {
32634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32635       };
32636     } catch (std::exception& e) {
32637       {
32638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32639       };
32640     } catch (Dali::DaliException e) {
32641       {
32642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32643       };
32644     } catch (...) {
32645       {
32646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32647       };
32648     }
32649   }
32650
32651   jresult = (int)result;
32652   return jresult;
32653 }
32654
32655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32656   Dali::Actor arg1 ;
32657   Dali::Actor *argp1 ;
32658
32659   argp1 = (Dali::Actor *)jarg1;
32660   if (!argp1) {
32661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32662     return ;
32663   }
32664   arg1 = *argp1;
32665   {
32666     try {
32667       arg1.Raise();
32668     } catch (std::out_of_range& e) {
32669       {
32670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32671       };
32672     } catch (std::exception& e) {
32673       {
32674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32675       };
32676     } catch (Dali::DaliException e) {
32677       {
32678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32679       };
32680     } catch (...) {
32681       {
32682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32683       };
32684     }
32685   }
32686
32687 }
32688
32689
32690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32691   Dali::Actor arg1 ;
32692   Dali::Actor *argp1 ;
32693
32694   argp1 = (Dali::Actor *)jarg1;
32695   if (!argp1) {
32696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32697     return ;
32698   }
32699   arg1 = *argp1;
32700   {
32701     try {
32702       arg1.Lower();
32703     } catch (std::out_of_range& e) {
32704       {
32705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32706       };
32707     } catch (std::exception& e) {
32708       {
32709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32710       };
32711     } catch (Dali::DaliException e) {
32712       {
32713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32714       };
32715     } catch (...) {
32716       {
32717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32718       };
32719     }
32720   }
32721
32722 }
32723
32724
32725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32726   Dali::Actor arg1 ;
32727   Dali::Actor *argp1 ;
32728
32729   argp1 = (Dali::Actor *)jarg1;
32730   if (!argp1) {
32731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32732     return ;
32733   }
32734   arg1 = *argp1;
32735   {
32736     try {
32737       arg1.RaiseToTop();
32738     } catch (std::out_of_range& e) {
32739       {
32740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32741       };
32742     } catch (std::exception& e) {
32743       {
32744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32745       };
32746     } catch (Dali::DaliException e) {
32747       {
32748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32749       };
32750     } catch (...) {
32751       {
32752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32753       };
32754     }
32755   }
32756
32757 }
32758
32759
32760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32761   Dali::Actor arg1 ;
32762   Dali::Actor *argp1 ;
32763
32764   argp1 = (Dali::Actor *)jarg1;
32765   if (!argp1) {
32766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32767     return ;
32768   }
32769   arg1 = *argp1;
32770   {
32771     try {
32772       arg1.LowerToBottom();
32773     } catch (std::out_of_range& e) {
32774       {
32775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32776       };
32777     } catch (std::exception& e) {
32778       {
32779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32780       };
32781     } catch (Dali::DaliException e) {
32782       {
32783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32784       };
32785     } catch (...) {
32786       {
32787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32788       };
32789     }
32790   }
32791
32792 }
32793
32794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32795   Dali::Actor arg1 ;
32796   Dali::Actor arg2 ;
32797   Dali::Actor *argp1 ;
32798   Dali::Actor *argp2 ;
32799
32800   argp1 = (Dali::Actor *)jarg1;
32801   if (!argp1) {
32802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32803     return ;
32804   }
32805   arg1 = *argp1;
32806   argp2 = (Dali::Actor *)jarg2;
32807   if (!argp2) {
32808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32809     return ;
32810   }
32811   arg2 = *argp2;
32812   {
32813     try {
32814       arg1.RaiseAbove(arg2);
32815     } catch (std::out_of_range& e) {
32816       {
32817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32818       };
32819     } catch (std::exception& e) {
32820       {
32821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32822       };
32823     } catch (Dali::DaliException e) {
32824       {
32825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32826       };
32827     } catch (...) {
32828       {
32829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32830       };
32831     }
32832   }
32833
32834 }
32835
32836
32837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32838   Dali::Actor arg1 ;
32839   Dali::Actor arg2 ;
32840   Dali::Actor *argp1 ;
32841   Dali::Actor *argp2 ;
32842
32843   argp1 = (Dali::Actor *)jarg1;
32844   if (!argp1) {
32845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32846     return ;
32847   }
32848   arg1 = *argp1;
32849   argp2 = (Dali::Actor *)jarg2;
32850   if (!argp2) {
32851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32852     return ;
32853   }
32854   arg2 = *argp2;
32855   {
32856     try {
32857       arg1.LowerBelow(arg2);
32858     } catch (std::out_of_range& e) {
32859       {
32860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32861       };
32862     } catch (std::exception& e) {
32863       {
32864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32865       };
32866     } catch (Dali::DaliException e) {
32867       {
32868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32869       };
32870     } catch (...) {
32871       {
32872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32873       };
32874     }
32875   }
32876
32877 }
32878
32879
32880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32881   void * jresult ;
32882   Dali::Actor arg1 ;
32883   Dali::Actor *argp1 ;
32884   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32885
32886   argp1 = (Dali::Actor *)jarg1;
32887   if (!argp1) {
32888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32889     return 0;
32890   }
32891   arg1 = *argp1;
32892   {
32893     try {
32894       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32895     } catch (std::out_of_range& e) {
32896       {
32897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32898       };
32899     } catch (std::exception& e) {
32900       {
32901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32902       };
32903     } catch (Dali::DaliException e) {
32904       {
32905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32906       };
32907     } catch (...) {
32908       {
32909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32910       };
32911     }
32912   }
32913
32914   jresult = (void *)result;
32915   return jresult;
32916 }
32917
32918
32919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32920   void * jresult ;
32921   Dali::Actor *arg1 ;
32922   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32923
32924   arg1 = (Dali::Actor *)jarg1;
32925   {
32926     try {
32927       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32928     } catch (std::out_of_range& e) {
32929       {
32930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32931       };
32932     } catch (std::exception& e) {
32933       {
32934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32935       };
32936     } catch (Dali::DaliException e) {
32937       {
32938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32939       };
32940     } catch (...) {
32941       {
32942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32943       };
32944     }
32945   }
32946
32947   jresult = (void *)result;
32948   return jresult;
32949 }
32950
32951
32952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32953   int jresult ;
32954   int result;
32955
32956   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32957   jresult = (int)result;
32958   return jresult;
32959 }
32960
32961
32962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32963   int jresult ;
32964   int result;
32965
32966   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32967   jresult = (int)result;
32968   return jresult;
32969 }
32970
32971
32972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32973   int jresult ;
32974   int result;
32975
32976   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32977   jresult = (int)result;
32978   return jresult;
32979 }
32980
32981
32982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32983   int jresult ;
32984   int result;
32985
32986   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32987   jresult = (int)result;
32988   return jresult;
32989 }
32990
32991
32992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32993   int jresult ;
32994   int result;
32995
32996   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32997   jresult = (int)result;
32998   return jresult;
32999 }
33000
33001
33002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
33003   int jresult ;
33004   int result;
33005
33006   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
33007   jresult = (int)result;
33008   return jresult;
33009 }
33010
33011
33012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
33013   int jresult ;
33014   int result;
33015
33016   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
33017   jresult = (int)result;
33018   return jresult;
33019 }
33020
33021
33022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33023   int jresult ;
33024   int result;
33025
33026   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33027   jresult = (int)result;
33028   return jresult;
33029 }
33030
33031
33032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33033   int jresult ;
33034   int result;
33035
33036   result = (int)Dali::Actor::Property::SIZE;
33037   jresult = (int)result;
33038   return jresult;
33039 }
33040
33041
33042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33043   int jresult ;
33044   int result;
33045
33046   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33047   jresult = (int)result;
33048   return jresult;
33049 }
33050
33051
33052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33053   int jresult ;
33054   int result;
33055
33056   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33057   jresult = (int)result;
33058   return jresult;
33059 }
33060
33061
33062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33063   int jresult ;
33064   int result;
33065
33066   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33067   jresult = (int)result;
33068   return jresult;
33069 }
33070
33071
33072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33073   int jresult ;
33074   int result;
33075
33076   result = (int)Dali::Actor::Property::POSITION;
33077   jresult = (int)result;
33078   return jresult;
33079 }
33080
33081
33082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33083   int jresult ;
33084   int result;
33085
33086   result = (int)Dali::Actor::Property::POSITION_X;
33087   jresult = (int)result;
33088   return jresult;
33089 }
33090
33091
33092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33093   int jresult ;
33094   int result;
33095
33096   result = (int)Dali::Actor::Property::POSITION_Y;
33097   jresult = (int)result;
33098   return jresult;
33099 }
33100
33101
33102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33103   int jresult ;
33104   int result;
33105
33106   result = (int)Dali::Actor::Property::POSITION_Z;
33107   jresult = (int)result;
33108   return jresult;
33109 }
33110
33111
33112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33113   int jresult ;
33114   int result;
33115
33116   result = (int)Dali::Actor::Property::WORLD_POSITION;
33117   jresult = (int)result;
33118   return jresult;
33119 }
33120
33121
33122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33123   int jresult ;
33124   int result;
33125
33126   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33127   jresult = (int)result;
33128   return jresult;
33129 }
33130
33131
33132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33133   int jresult ;
33134   int result;
33135
33136   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33137   jresult = (int)result;
33138   return jresult;
33139 }
33140
33141
33142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33143   int jresult ;
33144   int result;
33145
33146   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33147   jresult = (int)result;
33148   return jresult;
33149 }
33150
33151
33152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33153   int jresult ;
33154   int result;
33155
33156   result = (int)Dali::Actor::Property::ORIENTATION;
33157   jresult = (int)result;
33158   return jresult;
33159 }
33160
33161
33162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33163   int jresult ;
33164   int result;
33165
33166   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33167   jresult = (int)result;
33168   return jresult;
33169 }
33170
33171
33172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33173   int jresult ;
33174   int result;
33175
33176   result = (int)Dali::Actor::Property::SCALE;
33177   jresult = (int)result;
33178   return jresult;
33179 }
33180
33181
33182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33183   int jresult ;
33184   int result;
33185
33186   result = (int)Dali::Actor::Property::SCALE_X;
33187   jresult = (int)result;
33188   return jresult;
33189 }
33190
33191
33192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33193   int jresult ;
33194   int result;
33195
33196   result = (int)Dali::Actor::Property::SCALE_Y;
33197   jresult = (int)result;
33198   return jresult;
33199 }
33200
33201
33202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33203   int jresult ;
33204   int result;
33205
33206   result = (int)Dali::Actor::Property::SCALE_Z;
33207   jresult = (int)result;
33208   return jresult;
33209 }
33210
33211
33212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33213   int jresult ;
33214   int result;
33215
33216   result = (int)Dali::Actor::Property::WORLD_SCALE;
33217   jresult = (int)result;
33218   return jresult;
33219 }
33220
33221
33222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33223   int jresult ;
33224   int result;
33225
33226   result = (int)Dali::Actor::Property::VISIBLE;
33227   jresult = (int)result;
33228   return jresult;
33229 }
33230
33231
33232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33233   int jresult ;
33234   int result;
33235
33236   result = (int)Dali::Actor::Property::COLOR;
33237   jresult = (int)result;
33238   return jresult;
33239 }
33240
33241
33242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33243   int jresult ;
33244   int result;
33245
33246   result = (int)Dali::Actor::Property::COLOR_RED;
33247   jresult = (int)result;
33248   return jresult;
33249 }
33250
33251
33252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33253   int jresult ;
33254   int result;
33255
33256   result = (int)Dali::Actor::Property::COLOR_GREEN;
33257   jresult = (int)result;
33258   return jresult;
33259 }
33260
33261
33262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33263   int jresult ;
33264   int result;
33265
33266   result = (int)Dali::Actor::Property::COLOR_BLUE;
33267   jresult = (int)result;
33268   return jresult;
33269 }
33270
33271
33272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33273   int jresult ;
33274   int result;
33275
33276   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33277   jresult = (int)result;
33278   return jresult;
33279 }
33280
33281
33282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33283   int jresult ;
33284   int result;
33285
33286   result = (int)Dali::Actor::Property::WORLD_COLOR;
33287   jresult = (int)result;
33288   return jresult;
33289 }
33290
33291
33292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33293   int jresult ;
33294   int result;
33295
33296   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33297   jresult = (int)result;
33298   return jresult;
33299 }
33300
33301
33302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33303   int jresult ;
33304   int result;
33305
33306   result = (int)Dali::Actor::Property::NAME;
33307   jresult = (int)result;
33308   return jresult;
33309 }
33310
33311
33312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33313   int jresult ;
33314   int result;
33315
33316   result = (int)Dali::Actor::Property::SENSITIVE;
33317   jresult = (int)result;
33318   return jresult;
33319 }
33320
33321
33322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33323   int jresult ;
33324   int result;
33325
33326   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33327   jresult = (int)result;
33328   return jresult;
33329 }
33330
33331
33332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33333   int jresult ;
33334   int result;
33335
33336   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33337   jresult = (int)result;
33338   return jresult;
33339 }
33340
33341
33342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33343   int jresult ;
33344   int result;
33345
33346   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33347   jresult = (int)result;
33348   return jresult;
33349 }
33350
33351
33352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33353   int jresult ;
33354   int result;
33355
33356   result = (int)Dali::Actor::Property::COLOR_MODE;
33357   jresult = (int)result;
33358   return jresult;
33359 }
33360
33361
33362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33363   int jresult ;
33364   int result;
33365
33366   result = (int)Dali::Actor::Property::DRAW_MODE;
33367   jresult = (int)result;
33368   return jresult;
33369 }
33370
33371
33372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33373   int jresult ;
33374   int result;
33375
33376   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33377   jresult = (int)result;
33378   return jresult;
33379 }
33380
33381
33382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33383   int jresult ;
33384   int result;
33385
33386   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33387   jresult = (int)result;
33388   return jresult;
33389 }
33390
33391
33392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33393   int jresult ;
33394   int result;
33395
33396   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33397   jresult = (int)result;
33398   return jresult;
33399 }
33400
33401
33402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33403   int jresult ;
33404   int result;
33405
33406   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33407   jresult = (int)result;
33408   return jresult;
33409 }
33410
33411
33412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33413   int jresult ;
33414   int result;
33415
33416   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33417   jresult = (int)result;
33418   return jresult;
33419 }
33420
33421
33422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33423   int jresult ;
33424   int result;
33425
33426   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33427   jresult = (int)result;
33428   return jresult;
33429 }
33430
33431
33432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33433   int jresult ;
33434   int result;
33435
33436   result = (int)Dali::Actor::Property::PADDING;
33437   jresult = (int)result;
33438   return jresult;
33439 }
33440
33441
33442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33443   int jresult ;
33444   int result;
33445
33446   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33447   jresult = (int)result;
33448   return jresult;
33449 }
33450
33451
33452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33453   int jresult ;
33454   int result;
33455
33456   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33457   jresult = (int)result;
33458   return jresult;
33459 }
33460
33461
33462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33463   int jresult ;
33464   int result;
33465
33466   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33467   jresult = (int)result;
33468   return jresult;
33469 }
33470
33471
33472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33473   int jresult ;
33474   int result;
33475
33476   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33477   jresult = (int)result;
33478   return jresult;
33479 }
33480
33481 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33482
33483   return Dali::Actor::Property::OPACITY;
33484 }
33485
33486 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33487
33488   return Dali::Actor::Property::SCREEN_POSITION;
33489 }
33490
33491 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33492
33493   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33494 }
33495
33496 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33497   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33498 }
33499
33500 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33501   return Dali::Actor::Property::LAYOUT_DIRECTION;
33502 }
33503
33504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33505   void * jresult ;
33506   Dali::Actor::Property *result = 0 ;
33507
33508   {
33509     try {
33510       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33511     } catch (std::out_of_range& e) {
33512       {
33513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33514       };
33515     } catch (std::exception& e) {
33516       {
33517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33518       };
33519     } catch (Dali::DaliException e) {
33520       {
33521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33522       };
33523     } catch (...) {
33524       {
33525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33526       };
33527     }
33528   }
33529
33530   jresult = (void *)result;
33531   return jresult;
33532 }
33533
33534
33535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33536   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33537
33538   arg1 = (Dali::Actor::Property *)jarg1;
33539   {
33540     try {
33541       delete arg1;
33542     } catch (std::out_of_range& e) {
33543       {
33544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33545       };
33546     } catch (std::exception& e) {
33547       {
33548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33549       };
33550     } catch (Dali::DaliException e) {
33551       {
33552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33553       };
33554     } catch (...) {
33555       {
33556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33557       };
33558     }
33559   }
33560
33561 }
33562
33563
33564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33565   void * jresult ;
33566   Dali::Actor *result = 0 ;
33567
33568   {
33569     try {
33570       result = (Dali::Actor *)new Dali::Actor();
33571     } catch (std::out_of_range& e) {
33572       {
33573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33574       };
33575     } catch (std::exception& e) {
33576       {
33577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33578       };
33579     } catch (Dali::DaliException e) {
33580       {
33581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33582       };
33583     } catch (...) {
33584       {
33585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33586       };
33587     }
33588   }
33589
33590   jresult = (void *)result;
33591   return jresult;
33592 }
33593
33594
33595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33596   void * jresult ;
33597   Dali::Actor result;
33598
33599   {
33600     try {
33601       result = Dali::Actor::New();
33602     } catch (std::out_of_range& e) {
33603       {
33604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33605       };
33606     } catch (std::exception& e) {
33607       {
33608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33609       };
33610     } catch (Dali::DaliException e) {
33611       {
33612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33613       };
33614     } catch (...) {
33615       {
33616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33617       };
33618     }
33619   }
33620
33621   jresult = new Dali::Actor((const Dali::Actor &)result);
33622   return jresult;
33623 }
33624
33625
33626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33627   void * jresult ;
33628   Dali::BaseHandle arg1 ;
33629   Dali::BaseHandle *argp1 ;
33630   Dali::Actor result;
33631
33632   argp1 = (Dali::BaseHandle *)jarg1;
33633   if (!argp1) {
33634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33635     return 0;
33636   }
33637   arg1 = *argp1;
33638   {
33639     try {
33640       result = Dali::Actor::DownCast(arg1);
33641     } catch (std::out_of_range& e) {
33642       {
33643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33644       };
33645     } catch (std::exception& e) {
33646       {
33647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33648       };
33649     } catch (Dali::DaliException e) {
33650       {
33651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33652       };
33653     } catch (...) {
33654       {
33655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33656       };
33657     }
33658   }
33659
33660   jresult = new Dali::Actor((const Dali::Actor &)result);
33661   return jresult;
33662 }
33663
33664
33665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33666   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33667
33668   arg1 = (Dali::Actor *)jarg1;
33669   {
33670     try {
33671       delete arg1;
33672     } catch (std::out_of_range& e) {
33673       {
33674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33675       };
33676     } catch (std::exception& e) {
33677       {
33678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33679       };
33680     } catch (Dali::DaliException e) {
33681       {
33682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33683       };
33684     } catch (...) {
33685       {
33686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33687       };
33688     }
33689   }
33690
33691 }
33692
33693
33694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33695   void * jresult ;
33696   Dali::Actor *arg1 = 0 ;
33697   Dali::Actor *result = 0 ;
33698
33699   arg1 = (Dali::Actor *)jarg1;
33700   if (!arg1) {
33701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33702     return 0;
33703   }
33704   {
33705     try {
33706       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33707     } catch (std::out_of_range& e) {
33708       {
33709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (std::exception& e) {
33712       {
33713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33714       };
33715     } catch (Dali::DaliException e) {
33716       {
33717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33718       };
33719     } catch (...) {
33720       {
33721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33722       };
33723     }
33724   }
33725
33726   jresult = (void *)result;
33727   return jresult;
33728 }
33729
33730
33731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33732   void * jresult ;
33733   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33734   Dali::Actor *arg2 = 0 ;
33735   Dali::Actor *result = 0 ;
33736
33737   arg1 = (Dali::Actor *)jarg1;
33738   arg2 = (Dali::Actor *)jarg2;
33739   if (!arg2) {
33740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33741     return 0;
33742   }
33743   {
33744     try {
33745       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
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 = (void *)result;
33766   return jresult;
33767 }
33768
33769
33770 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33771   char * jresult ;
33772   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33773   std::string *result = 0 ;
33774   std::string name = "";
33775
33776   arg1 = (Dali::Actor *)jarg1;
33777   {
33778     try {
33779       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33780       result = (std::string *) &name;
33781       jresult = SWIG_csharp_string_callback(result->c_str());
33782     } catch (std::out_of_range& e) {
33783       {
33784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33785       };
33786     } catch (std::exception& e) {
33787       {
33788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33789       };
33790     } catch (Dali::DaliException e) {
33791       {
33792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33793       };
33794     } catch (...) {
33795       {
33796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33797       };
33798     }
33799   }
33800   return jresult;
33801 }
33802
33803
33804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33806   std::string *arg2 = 0 ;
33807
33808   arg1 = (Dali::Actor *)jarg1;
33809   if (!jarg2) {
33810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33811     return ;
33812   }
33813   std::string arg2_str(jarg2);
33814   arg2 = &arg2_str;
33815   {
33816     try {
33817       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33818     } catch (std::out_of_range& e) {
33819       {
33820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33821       };
33822     } catch (std::exception& e) {
33823       {
33824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33825       };
33826     } catch (Dali::DaliException e) {
33827       {
33828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33829       };
33830     } catch (...) {
33831       {
33832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33833       };
33834     }
33835   }
33836
33837
33838   //argout typemap for const std::string&
33839
33840 }
33841
33842
33843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33844   unsigned int jresult ;
33845   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33846   unsigned int result;
33847
33848   arg1 = (Dali::Actor *)jarg1;
33849
33850   if(!arg1) {
33851     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33852     return -1;
33853   }
33854
33855   {
33856     try {
33857       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33858     } catch (std::out_of_range& e) {
33859       {
33860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33861       };
33862     } catch (std::exception& e) {
33863       {
33864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33865       };
33866     } catch (Dali::DaliException e) {
33867       {
33868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33869       };
33870     } catch (...) {
33871       {
33872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33873       };
33874     }
33875   }
33876
33877   jresult = result;
33878   return jresult;
33879 }
33880
33881
33882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33883   unsigned int jresult ;
33884   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33885   bool result;
33886
33887   arg1 = (Dali::Actor *)jarg1;
33888   {
33889     try {
33890       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33891     } catch (std::out_of_range& e) {
33892       {
33893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33894       };
33895     } catch (std::exception& e) {
33896       {
33897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33898       };
33899     } catch (Dali::DaliException e) {
33900       {
33901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33902       };
33903     } catch (...) {
33904       {
33905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33906       };
33907     }
33908   }
33909
33910   jresult = result;
33911   return jresult;
33912 }
33913
33914
33915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33916   unsigned int jresult ;
33917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33918   bool result;
33919
33920   arg1 = (Dali::Actor *)jarg1;
33921   {
33922     try {
33923       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33924     } catch (std::out_of_range& e) {
33925       {
33926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33927       };
33928     } catch (std::exception& e) {
33929       {
33930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33931       };
33932     } catch (Dali::DaliException e) {
33933       {
33934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33935       };
33936     } catch (...) {
33937       {
33938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33939       };
33940     }
33941   }
33942
33943   jresult = result;
33944   return jresult;
33945 }
33946
33947
33948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33949   unsigned int jresult ;
33950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33951   bool result;
33952
33953   arg1 = (Dali::Actor *)jarg1;
33954   {
33955     try {
33956       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33957     } catch (std::out_of_range& e) {
33958       {
33959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33960       };
33961     } catch (std::exception& e) {
33962       {
33963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33964       };
33965     } catch (Dali::DaliException e) {
33966       {
33967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33968       };
33969     } catch (...) {
33970       {
33971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33972       };
33973     }
33974   }
33975
33976   jresult = result;
33977   return jresult;
33978 }
33979
33980
33981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33982   void * jresult ;
33983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33984   Dali::Layer result;
33985
33986   arg1 = (Dali::Actor *)jarg1;
33987   {
33988     try {
33989       result = (arg1)->GetLayer();
33990     } catch (std::out_of_range& e) {
33991       {
33992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33993       };
33994     } catch (std::exception& e) {
33995       {
33996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33997       };
33998     } catch (Dali::DaliException e) {
33999       {
34000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34001       };
34002     } catch (...) {
34003       {
34004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34005       };
34006     }
34007   }
34008
34009   jresult = new Dali::Layer((const Dali::Layer &)result);
34010   return jresult;
34011 }
34012
34013
34014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
34015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34016   Dali::Actor arg2 ;
34017   Dali::Actor *argp2 ;
34018
34019   arg1 = (Dali::Actor *)jarg1;
34020   argp2 = (Dali::Actor *)jarg2;
34021   if (!argp2) {
34022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34023     return ;
34024   }
34025   arg2 = *argp2;
34026   {
34027     try {
34028       (arg1)->Add(arg2);
34029     } catch (std::out_of_range& e) {
34030       {
34031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34032       };
34033     } catch (std::exception& e) {
34034       {
34035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34036       };
34037     } catch (Dali::DaliException e) {
34038       {
34039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34040       };
34041     } catch (...) {
34042       {
34043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34044       };
34045     }
34046   }
34047
34048 }
34049
34050
34051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34053   Dali::Actor arg2 ;
34054   Dali::Actor *argp2 ;
34055
34056   arg1 = (Dali::Actor *)jarg1;
34057   argp2 = (Dali::Actor *)jarg2;
34058   if (!argp2) {
34059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34060     return ;
34061   }
34062   arg2 = *argp2;
34063   {
34064     try {
34065       (arg1)->Remove(arg2);
34066     } catch (std::out_of_range& e) {
34067       {
34068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34069       };
34070     } catch (std::exception& e) {
34071       {
34072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34073       };
34074     } catch (Dali::DaliException e) {
34075       {
34076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34077       };
34078     } catch (...) {
34079       {
34080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34081       };
34082     }
34083   }
34084
34085 }
34086
34087
34088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34090
34091   arg1 = (Dali::Actor *)jarg1;
34092   {
34093     try {
34094       (arg1)->Unparent();
34095     } catch (std::out_of_range& e) {
34096       {
34097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34098       };
34099     } catch (std::exception& e) {
34100       {
34101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34102       };
34103     } catch (Dali::DaliException e) {
34104       {
34105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34106       };
34107     } catch (...) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34110       };
34111     }
34112   }
34113
34114 }
34115
34116
34117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34118   unsigned int jresult ;
34119   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34120   unsigned int result;
34121
34122   arg1 = (Dali::Actor *)jarg1;
34123   {
34124     try {
34125       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34126     } catch (std::out_of_range& e) {
34127       {
34128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34129       };
34130     } catch (std::exception& e) {
34131       {
34132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34133       };
34134     } catch (Dali::DaliException e) {
34135       {
34136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34137       };
34138     } catch (...) {
34139       {
34140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34141       };
34142     }
34143   }
34144
34145   jresult = result;
34146   return jresult;
34147 }
34148
34149
34150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34151   void * jresult ;
34152   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34153   unsigned int arg2 ;
34154   Dali::Actor result;
34155
34156   arg1 = (Dali::Actor *)jarg1;
34157   arg2 = (unsigned int)jarg2;
34158   {
34159     try {
34160       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34161     } catch (std::out_of_range& e) {
34162       {
34163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34164       };
34165     } catch (std::exception& e) {
34166       {
34167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34168       };
34169     } catch (Dali::DaliException e) {
34170       {
34171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34172       };
34173     } catch (...) {
34174       {
34175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34176       };
34177     }
34178   }
34179
34180   jresult = new Dali::Actor((const Dali::Actor &)result);
34181   return jresult;
34182 }
34183
34184
34185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34186   void * jresult ;
34187   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34188   std::string *arg2 = 0 ;
34189   Dali::Actor result;
34190
34191   arg1 = (Dali::Actor *)jarg1;
34192   if (!jarg2) {
34193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34194     return 0;
34195   }
34196   std::string arg2_str(jarg2);
34197   arg2 = &arg2_str;
34198   {
34199     try {
34200       result = (arg1)->FindChildByName((std::string const &)*arg2);
34201     } catch (std::out_of_range& e) {
34202       {
34203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34204       };
34205     } catch (std::exception& e) {
34206       {
34207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34208       };
34209     } catch (Dali::DaliException e) {
34210       {
34211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34212       };
34213     } catch (...) {
34214       {
34215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34216       };
34217     }
34218   }
34219
34220   jresult = new Dali::Actor((const Dali::Actor &)result);
34221
34222   //argout typemap for const std::string&
34223
34224   return jresult;
34225 }
34226
34227
34228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34229   void * jresult ;
34230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34231   unsigned int arg2 ;
34232   Dali::Actor result;
34233
34234   arg1 = (Dali::Actor *)jarg1;
34235   arg2 = (unsigned int)jarg2;
34236   {
34237     try {
34238       result = (arg1)->FindChildById(arg2);
34239     } catch (std::out_of_range& e) {
34240       {
34241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34242       };
34243     } catch (std::exception& e) {
34244       {
34245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34246       };
34247     } catch (Dali::DaliException e) {
34248       {
34249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34250       };
34251     } catch (...) {
34252       {
34253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34254       };
34255     }
34256   }
34257
34258   jresult = new Dali::Actor((const Dali::Actor &)result);
34259   return jresult;
34260 }
34261
34262
34263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34264   void * jresult ;
34265   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34266   Dali::Actor result;
34267
34268   arg1 = (Dali::Actor *)jarg1;
34269   {
34270     try {
34271       result = ((Dali::Actor const *)arg1)->GetParent();
34272     } catch (std::out_of_range& e) {
34273       {
34274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34275       };
34276     } catch (std::exception& e) {
34277       {
34278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34279       };
34280     } catch (Dali::DaliException e) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34283       };
34284     } catch (...) {
34285       {
34286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34287       };
34288     }
34289   }
34290
34291   jresult = new Dali::Actor((const Dali::Actor &)result);
34292   return jresult;
34293 }
34294
34295
34296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34297   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34298   Dali::Vector3 *arg2 = 0 ;
34299
34300   arg1 = (Dali::Actor *)jarg1;
34301   arg2 = (Dali::Vector3 *)jarg2;
34302   if (!arg2) {
34303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34304     return ;
34305   }
34306   {
34307     try {
34308       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34309     } catch (std::out_of_range& e) {
34310       {
34311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34312       };
34313     } catch (std::exception& e) {
34314       {
34315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34316       };
34317     } catch (Dali::DaliException e) {
34318       {
34319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34320       };
34321     } catch (...) {
34322       {
34323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34324       };
34325     }
34326   }
34327
34328 }
34329
34330
34331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34332   void * jresult ;
34333   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34334   Dali::Vector3 result;
34335
34336   arg1 = (Dali::Actor *)jarg1;
34337   {
34338     try {
34339       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34340     } catch (std::out_of_range& e) {
34341       {
34342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34343       };
34344     } catch (std::exception& e) {
34345       {
34346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34347       };
34348     } catch (Dali::DaliException e) {
34349       {
34350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34351       };
34352     } catch (...) {
34353       {
34354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34355       };
34356     }
34357   }
34358
34359   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34360   return jresult;
34361 }
34362
34363
34364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34365   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34366   Dali::Vector3 *arg2 = 0 ;
34367
34368   arg1 = (Dali::Actor *)jarg1;
34369   arg2 = (Dali::Vector3 *)jarg2;
34370   if (!arg2) {
34371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34372     return ;
34373   }
34374   {
34375     try {
34376       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34377     } catch (std::out_of_range& e) {
34378       {
34379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34380       };
34381     } catch (std::exception& e) {
34382       {
34383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34384       };
34385     } catch (Dali::DaliException e) {
34386       {
34387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34388       };
34389     } catch (...) {
34390       {
34391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34392       };
34393     }
34394   }
34395
34396 }
34397
34398
34399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34400   void * jresult ;
34401   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34402   Dali::Vector3 result;
34403
34404   arg1 = (Dali::Actor *)jarg1;
34405   {
34406     try {
34407       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34408     } catch (std::out_of_range& e) {
34409       {
34410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34411       };
34412     } catch (std::exception& e) {
34413       {
34414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34415       };
34416     } catch (Dali::DaliException e) {
34417       {
34418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34419       };
34420     } catch (...) {
34421       {
34422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34423       };
34424     }
34425   }
34426
34427   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34428   return jresult;
34429 }
34430
34431
34432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34434   float arg2 ;
34435   float arg3 ;
34436
34437   arg1 = (Dali::Actor *)jarg1;
34438   arg2 = (float)jarg2;
34439   arg3 = (float)jarg3;
34440   {
34441     try {
34442       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34443     } catch (std::out_of_range& e) {
34444       {
34445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34446       };
34447     } catch (std::exception& e) {
34448       {
34449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34450       };
34451     } catch (Dali::DaliException e) {
34452       {
34453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34454       };
34455     } catch (...) {
34456       {
34457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34458       };
34459     }
34460   }
34461
34462 }
34463
34464
34465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34466   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34467   float arg2 ;
34468   float arg3 ;
34469   float arg4 ;
34470
34471   arg1 = (Dali::Actor *)jarg1;
34472   arg2 = (float)jarg2;
34473   arg3 = (float)jarg3;
34474   arg4 = (float)jarg4;
34475   {
34476     try {
34477       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34478     } catch (std::out_of_range& e) {
34479       {
34480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34481       };
34482     } catch (std::exception& e) {
34483       {
34484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34485       };
34486     } catch (Dali::DaliException e) {
34487       {
34488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34489       };
34490     } catch (...) {
34491       {
34492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34493       };
34494     }
34495   }
34496
34497 }
34498
34499
34500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34501   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34502   Dali::Vector2 *arg2 = 0 ;
34503
34504   arg1 = (Dali::Actor *)jarg1;
34505   arg2 = (Dali::Vector2 *)jarg2;
34506   if (!arg2) {
34507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34508     return ;
34509   }
34510   {
34511     try {
34512       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34513     } catch (std::out_of_range& e) {
34514       {
34515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34516       };
34517     } catch (std::exception& e) {
34518       {
34519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34520       };
34521     } catch (Dali::DaliException e) {
34522       {
34523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34524       };
34525     } catch (...) {
34526       {
34527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34528       };
34529     }
34530   }
34531
34532 }
34533
34534
34535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34537   Dali::Vector3 *arg2 = 0 ;
34538
34539   arg1 = (Dali::Actor *)jarg1;
34540   arg2 = (Dali::Vector3 *)jarg2;
34541   if (!arg2) {
34542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34543     return ;
34544   }
34545   {
34546     try {
34547       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34548     } catch (std::out_of_range& e) {
34549       {
34550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34551       };
34552     } catch (std::exception& e) {
34553       {
34554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34555       };
34556     } catch (Dali::DaliException e) {
34557       {
34558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34559       };
34560     } catch (...) {
34561       {
34562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34563       };
34564     }
34565   }
34566
34567 }
34568
34569
34570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34571   void * jresult ;
34572   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34573   Dali::Vector3 result;
34574
34575   arg1 = (Dali::Actor *)jarg1;
34576   {
34577     try {
34578       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34579     } catch (std::out_of_range& e) {
34580       {
34581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34582       };
34583     } catch (std::exception& e) {
34584       {
34585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34586       };
34587     } catch (Dali::DaliException e) {
34588       {
34589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34590       };
34591     } catch (...) {
34592       {
34593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34594       };
34595     }
34596   }
34597
34598   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34599   return jresult;
34600 }
34601
34602
34603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34604   void * jresult ;
34605   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34606   Dali::Vector3 result;
34607
34608   arg1 = (Dali::Actor *)jarg1;
34609   {
34610     try {
34611       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34612     } catch (std::out_of_range& e) {
34613       {
34614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34615       };
34616     } catch (std::exception& e) {
34617       {
34618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34619       };
34620     } catch (Dali::DaliException e) {
34621       {
34622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34623       };
34624     } catch (...) {
34625       {
34626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34627       };
34628     }
34629   }
34630
34631   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34632   return jresult;
34633 }
34634
34635
34636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34637   void * jresult ;
34638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34639   Dali::Vector3 result;
34640
34641   arg1 = (Dali::Actor *)jarg1;
34642   {
34643     try {
34644       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34645     } catch (std::out_of_range& e) {
34646       {
34647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34648       };
34649     } catch (std::exception& e) {
34650       {
34651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34652       };
34653     } catch (Dali::DaliException e) {
34654       {
34655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34656       };
34657     } catch (...) {
34658       {
34659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34660       };
34661     }
34662   }
34663
34664   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34665   return jresult;
34666 }
34667
34668
34669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34671   float arg2 ;
34672   float arg3 ;
34673
34674   arg1 = (Dali::Actor *)jarg1;
34675   arg2 = (float)jarg2;
34676   arg3 = (float)jarg3;
34677   {
34678     try {
34679       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34680     } catch (std::out_of_range& e) {
34681       {
34682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34683       };
34684     } catch (std::exception& e) {
34685       {
34686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34687       };
34688     } catch (Dali::DaliException e) {
34689       {
34690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34691       };
34692     } catch (...) {
34693       {
34694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34695       };
34696     }
34697   }
34698
34699 }
34700
34701
34702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34703   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34704   float arg2 ;
34705   float arg3 ;
34706   float arg4 ;
34707
34708   arg1 = (Dali::Actor *)jarg1;
34709   arg2 = (float)jarg2;
34710   arg3 = (float)jarg3;
34711   arg4 = (float)jarg4;
34712   {
34713     try {
34714       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34715     } catch (std::out_of_range& e) {
34716       {
34717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34718       };
34719     } catch (std::exception& e) {
34720       {
34721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34722       };
34723     } catch (Dali::DaliException e) {
34724       {
34725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34726       };
34727     } catch (...) {
34728       {
34729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34730       };
34731     }
34732   }
34733
34734 }
34735
34736
34737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34738   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34739   Dali::Vector3 *arg2 = 0 ;
34740
34741   arg1 = (Dali::Actor *)jarg1;
34742   arg2 = (Dali::Vector3 *)jarg2;
34743   if (!arg2) {
34744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34745     return ;
34746   }
34747   {
34748     try {
34749       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34750     } catch (std::out_of_range& e) {
34751       {
34752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34753       };
34754     } catch (std::exception& e) {
34755       {
34756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34757       };
34758     } catch (Dali::DaliException e) {
34759       {
34760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34761       };
34762     } catch (...) {
34763       {
34764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34765       };
34766     }
34767   }
34768
34769 }
34770
34771
34772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34773   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34774   float arg2 ;
34775
34776   arg1 = (Dali::Actor *)jarg1;
34777   arg2 = (float)jarg2;
34778   {
34779     try {
34780       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34781     } catch (std::out_of_range& e) {
34782       {
34783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34784       };
34785     } catch (std::exception& e) {
34786       {
34787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34788       };
34789     } catch (Dali::DaliException e) {
34790       {
34791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34792       };
34793     } catch (...) {
34794       {
34795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34796       };
34797     }
34798   }
34799
34800 }
34801
34802
34803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34805   float arg2 ;
34806
34807   arg1 = (Dali::Actor *)jarg1;
34808   arg2 = (float)jarg2;
34809   {
34810     try {
34811       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34812     } catch (std::out_of_range& e) {
34813       {
34814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34815       };
34816     } catch (std::exception& e) {
34817       {
34818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34819       };
34820     } catch (Dali::DaliException e) {
34821       {
34822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34823       };
34824     } catch (...) {
34825       {
34826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34827       };
34828     }
34829   }
34830
34831 }
34832
34833
34834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34835   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34836   float arg2 ;
34837
34838   arg1 = (Dali::Actor *)jarg1;
34839   arg2 = (float)jarg2;
34840   {
34841     try {
34842       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34843     } catch (std::out_of_range& e) {
34844       {
34845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34846       };
34847     } catch (std::exception& e) {
34848       {
34849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34850       };
34851     } catch (Dali::DaliException e) {
34852       {
34853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34854       };
34855     } catch (...) {
34856       {
34857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34858       };
34859     }
34860   }
34861
34862 }
34863
34864
34865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34866   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34867   Dali::Vector3 *arg2 = 0 ;
34868
34869   arg1 = (Dali::Actor *)jarg1;
34870   arg2 = (Dali::Vector3 *)jarg2;
34871   if (!arg2) {
34872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34873     return ;
34874   }
34875   {
34876     try {
34877       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34878     } catch (std::out_of_range& e) {
34879       {
34880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34881       };
34882     } catch (std::exception& e) {
34883       {
34884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34885       };
34886     } catch (Dali::DaliException e) {
34887       {
34888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34889       };
34890     } catch (...) {
34891       {
34892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34893       };
34894     }
34895   }
34896
34897 }
34898
34899
34900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34901   void * jresult ;
34902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34903   Dali::Vector3 result;
34904
34905   arg1 = (Dali::Actor *)jarg1;
34906   {
34907     try {
34908       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34909     } catch (std::out_of_range& e) {
34910       {
34911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34912       };
34913     } catch (std::exception& e) {
34914       {
34915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34916       };
34917     } catch (Dali::DaliException e) {
34918       {
34919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34920       };
34921     } catch (...) {
34922       {
34923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34924       };
34925     }
34926   }
34927
34928   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34929   return jresult;
34930 }
34931
34932
34933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34934   void * jresult ;
34935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34936   Dali::Vector3 result;
34937
34938   arg1 = (Dali::Actor *)jarg1;
34939   {
34940     try {
34941       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34942     } catch (std::out_of_range& e) {
34943       {
34944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34945       };
34946     } catch (std::exception& e) {
34947       {
34948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34949       };
34950     } catch (Dali::DaliException e) {
34951       {
34952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34953       };
34954     } catch (...) {
34955       {
34956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34957       };
34958     }
34959   }
34960
34961   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34962   return jresult;
34963 }
34964
34965
34966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34967   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34968   bool arg2 ;
34969
34970   arg1 = (Dali::Actor *)jarg1;
34971   arg2 = jarg2 ? true : false;
34972   {
34973     try {
34974       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34975     } catch (std::out_of_range& e) {
34976       {
34977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34978       };
34979     } catch (std::exception& e) {
34980       {
34981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34982       };
34983     } catch (Dali::DaliException e) {
34984       {
34985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34986       };
34987     } catch (...) {
34988       {
34989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34990       };
34991     }
34992   }
34993
34994 }
34995
34996
34997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34998   unsigned int jresult ;
34999   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35000   bool result;
35001
35002   arg1 = (Dali::Actor *)jarg1;
35003   {
35004     try {
35005       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
35006     } catch (std::out_of_range& e) {
35007       {
35008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35009       };
35010     } catch (std::exception& e) {
35011       {
35012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35013       };
35014     } catch (Dali::DaliException e) {
35015       {
35016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35017       };
35018     } catch (...) {
35019       {
35020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35021       };
35022     }
35023   }
35024
35025   jresult = result;
35026   return jresult;
35027 }
35028
35029
35030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35031   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35032   Dali::Degree *arg2 = 0 ;
35033   Dali::Vector3 *arg3 = 0 ;
35034
35035   arg1 = (Dali::Actor *)jarg1;
35036   arg2 = (Dali::Degree *)jarg2;
35037   if (!arg2) {
35038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35039     return ;
35040   }
35041   arg3 = (Dali::Vector3 *)jarg3;
35042   if (!arg3) {
35043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35044     return ;
35045   }
35046   {
35047     try {
35048       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35049     } catch (std::out_of_range& e) {
35050       {
35051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35052       };
35053     } catch (std::exception& e) {
35054       {
35055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35056       };
35057     } catch (Dali::DaliException e) {
35058       {
35059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35060       };
35061     } catch (...) {
35062       {
35063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35064       };
35065     }
35066   }
35067
35068 }
35069
35070
35071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35072   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35073   Dali::Radian *arg2 = 0 ;
35074   Dali::Vector3 *arg3 = 0 ;
35075
35076   arg1 = (Dali::Actor *)jarg1;
35077   arg2 = (Dali::Radian *)jarg2;
35078   if (!arg2) {
35079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35080     return ;
35081   }
35082   arg3 = (Dali::Vector3 *)jarg3;
35083   if (!arg3) {
35084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35085     return ;
35086   }
35087   {
35088     try {
35089       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35090     } catch (std::out_of_range& e) {
35091       {
35092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35093       };
35094     } catch (std::exception& e) {
35095       {
35096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35097       };
35098     } catch (Dali::DaliException e) {
35099       {
35100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35101       };
35102     } catch (...) {
35103       {
35104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35105       };
35106     }
35107   }
35108
35109 }
35110
35111
35112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35113   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35114   Dali::Quaternion *arg2 = 0 ;
35115
35116   arg1 = (Dali::Actor *)jarg1;
35117   arg2 = (Dali::Quaternion *)jarg2;
35118   if (!arg2) {
35119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35120     return ;
35121   }
35122   {
35123     try {
35124       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
35125     } catch (std::out_of_range& e) {
35126       {
35127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35128       };
35129     } catch (std::exception& e) {
35130       {
35131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35132       };
35133     } catch (Dali::DaliException e) {
35134       {
35135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35136       };
35137     } catch (...) {
35138       {
35139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35140       };
35141     }
35142   }
35143
35144 }
35145
35146
35147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35148   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35149   Dali::Degree *arg2 = 0 ;
35150   Dali::Vector3 *arg3 = 0 ;
35151
35152   arg1 = (Dali::Actor *)jarg1;
35153   arg2 = (Dali::Degree *)jarg2;
35154   if (!arg2) {
35155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35156     return ;
35157   }
35158   arg3 = (Dali::Vector3 *)jarg3;
35159   if (!arg3) {
35160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35161     return ;
35162   }
35163   {
35164     try {
35165       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35166     } catch (std::out_of_range& e) {
35167       {
35168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35169       };
35170     } catch (std::exception& e) {
35171       {
35172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35173       };
35174     } catch (Dali::DaliException e) {
35175       {
35176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35177       };
35178     } catch (...) {
35179       {
35180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35181       };
35182     }
35183   }
35184
35185 }
35186
35187
35188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35190   Dali::Radian *arg2 = 0 ;
35191   Dali::Vector3 *arg3 = 0 ;
35192
35193   arg1 = (Dali::Actor *)jarg1;
35194   arg2 = (Dali::Radian *)jarg2;
35195   if (!arg2) {
35196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35197     return ;
35198   }
35199   arg3 = (Dali::Vector3 *)jarg3;
35200   if (!arg3) {
35201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35202     return ;
35203   }
35204   {
35205     try {
35206       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35207     } catch (std::out_of_range& e) {
35208       {
35209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35210       };
35211     } catch (std::exception& e) {
35212       {
35213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35214       };
35215     } catch (Dali::DaliException e) {
35216       {
35217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35218       };
35219     } catch (...) {
35220       {
35221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35222       };
35223     }
35224   }
35225
35226 }
35227
35228
35229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35231   Dali::Quaternion *arg2 = 0 ;
35232
35233   arg1 = (Dali::Actor *)jarg1;
35234   arg2 = (Dali::Quaternion *)jarg2;
35235   if (!arg2) {
35236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35237     return ;
35238   }
35239   {
35240     try {
35241       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35242     } catch (std::out_of_range& e) {
35243       {
35244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35245       };
35246     } catch (std::exception& e) {
35247       {
35248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35249       };
35250     } catch (Dali::DaliException e) {
35251       {
35252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35253       };
35254     } catch (...) {
35255       {
35256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35257       };
35258     }
35259   }
35260
35261 }
35262
35263
35264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35265   void * jresult ;
35266   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35267   Dali::Quaternion result;
35268
35269   arg1 = (Dali::Actor *)jarg1;
35270   {
35271     try {
35272       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35273     } catch (std::out_of_range& e) {
35274       {
35275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35276       };
35277     } catch (std::exception& e) {
35278       {
35279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35280       };
35281     } catch (Dali::DaliException e) {
35282       {
35283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35284       };
35285     } catch (...) {
35286       {
35287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35288       };
35289     }
35290   }
35291
35292   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35293   return jresult;
35294 }
35295
35296
35297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35298   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35299   bool arg2 ;
35300
35301   arg1 = (Dali::Actor *)jarg1;
35302   arg2 = jarg2 ? true : false;
35303   {
35304     try {
35305       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35306     } catch (std::out_of_range& e) {
35307       {
35308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35309       };
35310     } catch (std::exception& e) {
35311       {
35312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35313       };
35314     } catch (Dali::DaliException e) {
35315       {
35316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35317       };
35318     } catch (...) {
35319       {
35320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35321       };
35322     }
35323   }
35324
35325 }
35326
35327
35328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35329   unsigned int jresult ;
35330   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35331   bool result;
35332
35333   arg1 = (Dali::Actor *)jarg1;
35334   {
35335     try {
35336       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35337     } catch (std::out_of_range& e) {
35338       {
35339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35340       };
35341     } catch (std::exception& e) {
35342       {
35343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35344       };
35345     } catch (Dali::DaliException e) {
35346       {
35347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35348       };
35349     } catch (...) {
35350       {
35351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35352       };
35353     }
35354   }
35355
35356   jresult = result;
35357   return jresult;
35358 }
35359
35360
35361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35362   void * jresult ;
35363   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35364   Dali::Quaternion result;
35365
35366   arg1 = (Dali::Actor *)jarg1;
35367   {
35368     try {
35369       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35370     } catch (std::out_of_range& e) {
35371       {
35372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35373       };
35374     } catch (std::exception& e) {
35375       {
35376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35377       };
35378     } catch (Dali::DaliException e) {
35379       {
35380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35381       };
35382     } catch (...) {
35383       {
35384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35385       };
35386     }
35387   }
35388
35389   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35390   return jresult;
35391 }
35392
35393
35394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35396   float arg2 ;
35397
35398   arg1 = (Dali::Actor *)jarg1;
35399   arg2 = (float)jarg2;
35400   {
35401     try {
35402       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35403     } catch (std::out_of_range& e) {
35404       {
35405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35406       };
35407     } catch (std::exception& e) {
35408       {
35409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35410       };
35411     } catch (Dali::DaliException e) {
35412       {
35413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35414       };
35415     } catch (...) {
35416       {
35417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35418       };
35419     }
35420   }
35421
35422 }
35423
35424
35425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35426   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35427   float arg2 ;
35428   float arg3 ;
35429   float arg4 ;
35430
35431   arg1 = (Dali::Actor *)jarg1;
35432   arg2 = (float)jarg2;
35433   arg3 = (float)jarg3;
35434   arg4 = (float)jarg4;
35435   {
35436     try {
35437       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35438     } catch (std::out_of_range& e) {
35439       {
35440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35441       };
35442     } catch (std::exception& e) {
35443       {
35444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35445       };
35446     } catch (Dali::DaliException e) {
35447       {
35448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35449       };
35450     } catch (...) {
35451       {
35452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35453       };
35454     }
35455   }
35456
35457 }
35458
35459
35460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35461   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35462   Dali::Vector3 *arg2 = 0 ;
35463
35464   arg1 = (Dali::Actor *)jarg1;
35465   arg2 = (Dali::Vector3 *)jarg2;
35466   if (!arg2) {
35467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35468     return ;
35469   }
35470   {
35471     try {
35472       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35473     } catch (std::out_of_range& e) {
35474       {
35475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35476       };
35477     } catch (std::exception& e) {
35478       {
35479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35480       };
35481     } catch (Dali::DaliException e) {
35482       {
35483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35484       };
35485     } catch (...) {
35486       {
35487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35488       };
35489     }
35490   }
35491
35492 }
35493
35494
35495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35497   Dali::Vector3 *arg2 = 0 ;
35498
35499   arg1 = (Dali::Actor *)jarg1;
35500   arg2 = (Dali::Vector3 *)jarg2;
35501   if (!arg2) {
35502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35503     return ;
35504   }
35505   {
35506     try {
35507       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35508     } catch (std::out_of_range& e) {
35509       {
35510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35511       };
35512     } catch (std::exception& e) {
35513       {
35514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35515       };
35516     } catch (Dali::DaliException e) {
35517       {
35518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35519       };
35520     } catch (...) {
35521       {
35522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35523       };
35524     }
35525   }
35526
35527 }
35528
35529
35530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35531   void * jresult ;
35532   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35533   Dali::Vector3 result;
35534
35535   arg1 = (Dali::Actor *)jarg1;
35536   {
35537     try {
35538       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35539     } catch (std::out_of_range& e) {
35540       {
35541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35542       };
35543     } catch (std::exception& e) {
35544       {
35545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35546       };
35547     } catch (Dali::DaliException e) {
35548       {
35549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35550       };
35551     } catch (...) {
35552       {
35553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35554       };
35555     }
35556   }
35557
35558   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35559   return jresult;
35560 }
35561
35562
35563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35564   void * jresult ;
35565   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35566   Dali::Vector3 result;
35567
35568   arg1 = (Dali::Actor *)jarg1;
35569   {
35570     try {
35571       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35572     } catch (std::out_of_range& e) {
35573       {
35574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35575       };
35576     } catch (std::exception& e) {
35577       {
35578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35579       };
35580     } catch (Dali::DaliException e) {
35581       {
35582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35583       };
35584     } catch (...) {
35585       {
35586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35587       };
35588     }
35589   }
35590
35591   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35592   return jresult;
35593 }
35594
35595
35596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35598   bool arg2 ;
35599
35600   arg1 = (Dali::Actor *)jarg1;
35601   arg2 = jarg2 ? true : false;
35602   {
35603     try {
35604       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35605     } catch (std::out_of_range& e) {
35606       {
35607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35608       };
35609     } catch (std::exception& e) {
35610       {
35611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35612       };
35613     } catch (Dali::DaliException e) {
35614       {
35615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35616       };
35617     } catch (...) {
35618       {
35619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35620       };
35621     }
35622   }
35623
35624 }
35625
35626
35627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35628   unsigned int jresult ;
35629   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35630   bool result;
35631
35632   arg1 = (Dali::Actor *)jarg1;
35633   {
35634     try {
35635       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35636     } catch (std::out_of_range& e) {
35637       {
35638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35639       };
35640     } catch (std::exception& e) {
35641       {
35642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35643       };
35644     } catch (Dali::DaliException e) {
35645       {
35646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35647       };
35648     } catch (...) {
35649       {
35650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35651       };
35652     }
35653   }
35654
35655   jresult = result;
35656   return jresult;
35657 }
35658
35659
35660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35661   void * jresult ;
35662   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35663   Dali::Matrix result;
35664
35665   arg1 = (Dali::Actor *)jarg1;
35666   {
35667     try {
35668       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35669     } catch (std::out_of_range& e) {
35670       {
35671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35672       };
35673     } catch (std::exception& e) {
35674       {
35675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35676       };
35677     } catch (Dali::DaliException e) {
35678       {
35679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35680       };
35681     } catch (...) {
35682       {
35683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35684       };
35685     }
35686   }
35687
35688   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35689   return jresult;
35690 }
35691
35692
35693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35694   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35695   bool arg2 ;
35696
35697   arg1 = (Dali::Actor *)jarg1;
35698   arg2 = jarg2 ? true : false;
35699   {
35700     try {
35701       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35702     } catch (std::out_of_range& e) {
35703       {
35704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35705       };
35706     } catch (std::exception& e) {
35707       {
35708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35709       };
35710     } catch (Dali::DaliException e) {
35711       {
35712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35713       };
35714     } catch (...) {
35715       {
35716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35717       };
35718     }
35719   }
35720
35721 }
35722
35723
35724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35725   unsigned int jresult ;
35726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35727   bool result;
35728
35729   arg1 = (Dali::Actor *)jarg1;
35730   {
35731     try {
35732       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35733     } catch (std::out_of_range& e) {
35734       {
35735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35736       };
35737     } catch (std::exception& e) {
35738       {
35739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35740       };
35741     } catch (Dali::DaliException e) {
35742       {
35743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35744       };
35745     } catch (...) {
35746       {
35747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35748       };
35749     }
35750   }
35751
35752   jresult = result;
35753   return jresult;
35754 }
35755
35756
35757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35758   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35759   float arg2 ;
35760
35761   arg1 = (Dali::Actor *)jarg1;
35762   arg2 = (float)jarg2;
35763   {
35764     try {
35765       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35766     } catch (std::out_of_range& e) {
35767       {
35768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35769       };
35770     } catch (std::exception& e) {
35771       {
35772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35773       };
35774     } catch (Dali::DaliException e) {
35775       {
35776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35777       };
35778     } catch (...) {
35779       {
35780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35781       };
35782     }
35783   }
35784
35785 }
35786
35787
35788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35789   float jresult ;
35790   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35791   float result;
35792
35793   arg1 = (Dali::Actor *)jarg1;
35794   {
35795     try {
35796       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35797     } catch (std::out_of_range& e) {
35798       {
35799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35800       };
35801     } catch (std::exception& e) {
35802       {
35803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35804       };
35805     } catch (Dali::DaliException e) {
35806       {
35807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35808       };
35809     } catch (...) {
35810       {
35811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35812       };
35813     }
35814   }
35815
35816   jresult = result;
35817   return jresult;
35818 }
35819
35820
35821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35823   Dali::Vector4 *arg2 = 0 ;
35824
35825   arg1 = (Dali::Actor *)jarg1;
35826   arg2 = (Dali::Vector4 *)jarg2;
35827   if (!arg2) {
35828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35829     return ;
35830   }
35831   {
35832     try {
35833       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35834     } catch (std::out_of_range& e) {
35835       {
35836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35837       };
35838     } catch (std::exception& e) {
35839       {
35840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35841       };
35842     } catch (Dali::DaliException e) {
35843       {
35844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35845       };
35846     } catch (...) {
35847       {
35848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35849       };
35850     }
35851   }
35852
35853 }
35854
35855
35856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35857   void * jresult ;
35858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35859   Dali::Vector4 result;
35860
35861   arg1 = (Dali::Actor *)jarg1;
35862   {
35863     try {
35864       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35865     } catch (std::out_of_range& e) {
35866       {
35867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35868       };
35869     } catch (std::exception& e) {
35870       {
35871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35872       };
35873     } catch (Dali::DaliException e) {
35874       {
35875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35876       };
35877     } catch (...) {
35878       {
35879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35880       };
35881     }
35882   }
35883
35884   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35885   return jresult;
35886 }
35887
35888
35889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35890   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35891   Dali::ColorMode arg2 ;
35892
35893   arg1 = (Dali::Actor *)jarg1;
35894   arg2 = (Dali::ColorMode)jarg2;
35895   {
35896     try {
35897       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35898     } catch (std::out_of_range& e) {
35899       {
35900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35901       };
35902     } catch (std::exception& e) {
35903       {
35904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35905       };
35906     } catch (Dali::DaliException e) {
35907       {
35908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35909       };
35910     } catch (...) {
35911       {
35912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35913       };
35914     }
35915   }
35916
35917 }
35918
35919
35920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35921   int jresult ;
35922   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35923   Dali::ColorMode result;
35924
35925   arg1 = (Dali::Actor *)jarg1;
35926   {
35927     try {
35928       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35929     } catch (std::out_of_range& e) {
35930       {
35931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35932       };
35933     } catch (std::exception& e) {
35934       {
35935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35936       };
35937     } catch (Dali::DaliException e) {
35938       {
35939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35940       };
35941     } catch (...) {
35942       {
35943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35944       };
35945     }
35946   }
35947
35948   jresult = (int)result;
35949   return jresult;
35950 }
35951
35952
35953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35954   void * jresult ;
35955   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35956   Dali::Vector4 result;
35957
35958   arg1 = (Dali::Actor *)jarg1;
35959   {
35960     try {
35961       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35962     } catch (std::out_of_range& e) {
35963       {
35964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35965       };
35966     } catch (std::exception& e) {
35967       {
35968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35969       };
35970     } catch (Dali::DaliException e) {
35971       {
35972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35973       };
35974     } catch (...) {
35975       {
35976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35977       };
35978     }
35979   }
35980
35981   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35982   return jresult;
35983 }
35984
35985
35986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35988   Dali::DrawMode::Type arg2 ;
35989
35990   arg1 = (Dali::Actor *)jarg1;
35991   arg2 = (Dali::DrawMode::Type)jarg2;
35992   {
35993     try {
35994       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35995     } catch (std::out_of_range& e) {
35996       {
35997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35998       };
35999     } catch (std::exception& e) {
36000       {
36001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36002       };
36003     } catch (Dali::DaliException e) {
36004       {
36005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36006       };
36007     } catch (...) {
36008       {
36009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36010       };
36011     }
36012   }
36013
36014 }
36015
36016
36017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
36018   int jresult ;
36019   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36020   Dali::DrawMode::Type result;
36021
36022   arg1 = (Dali::Actor *)jarg1;
36023   {
36024     try {
36025       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
36026     } catch (std::out_of_range& e) {
36027       {
36028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36029       };
36030     } catch (std::exception& e) {
36031       {
36032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36033       };
36034     } catch (Dali::DaliException e) {
36035       {
36036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36037       };
36038     } catch (...) {
36039       {
36040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36041       };
36042     }
36043   }
36044
36045   jresult = (int)result;
36046   return jresult;
36047 }
36048
36049
36050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36051   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36052   bool arg2 ;
36053
36054   arg1 = (Dali::Actor *)jarg1;
36055   arg2 = jarg2 ? true : false;
36056   {
36057     try {
36058       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
36059     } catch (std::out_of_range& e) {
36060       {
36061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36062       };
36063     } catch (std::exception& e) {
36064       {
36065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36066       };
36067     } catch (Dali::DaliException e) {
36068       {
36069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36070       };
36071     } catch (...) {
36072       {
36073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36074       };
36075     }
36076   }
36077
36078 }
36079
36080
36081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36082   unsigned int jresult ;
36083   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36084   bool result;
36085
36086   arg1 = (Dali::Actor *)jarg1;
36087   {
36088     try {
36089       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
36090     } catch (std::out_of_range& e) {
36091       {
36092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36093       };
36094     } catch (std::exception& e) {
36095       {
36096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36097       };
36098     } catch (Dali::DaliException e) {
36099       {
36100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36101       };
36102     } catch (...) {
36103       {
36104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36105       };
36106     }
36107   }
36108
36109   jresult = result;
36110   return jresult;
36111 }
36112
36113
36114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36115   unsigned int jresult ;
36116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36117   float *arg2 = 0 ;
36118   float *arg3 = 0 ;
36119   float arg4 ;
36120   float arg5 ;
36121   bool result;
36122
36123   arg1 = (Dali::Actor *)jarg1;
36124   arg2 = (float *)jarg2;
36125   arg3 = (float *)jarg3;
36126   arg4 = (float)jarg4;
36127   arg5 = (float)jarg5;
36128   {
36129     try {
36130       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36131     } catch (std::out_of_range& e) {
36132       {
36133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36134       };
36135     } catch (std::exception& e) {
36136       {
36137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36138       };
36139     } catch (Dali::DaliException e) {
36140       {
36141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36142       };
36143     } catch (...) {
36144       {
36145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36146       };
36147     }
36148   }
36149
36150   jresult = result;
36151   return jresult;
36152 }
36153
36154
36155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36156   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36157   bool arg2 ;
36158
36159   arg1 = (Dali::Actor *)jarg1;
36160   arg2 = jarg2 ? true : false;
36161   {
36162     try {
36163       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
36164     } catch (std::out_of_range& e) {
36165       {
36166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36167       };
36168     } catch (std::exception& e) {
36169       {
36170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36171       };
36172     } catch (Dali::DaliException e) {
36173       {
36174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36175       };
36176     } catch (...) {
36177       {
36178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36179       };
36180     }
36181   }
36182
36183 }
36184
36185
36186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36187   unsigned int jresult ;
36188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36189   bool result;
36190
36191   arg1 = (Dali::Actor *)jarg1;
36192   {
36193     try {
36194       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36195     } catch (std::out_of_range& e) {
36196       {
36197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36198       };
36199     } catch (std::exception& e) {
36200       {
36201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36202       };
36203     } catch (Dali::DaliException e) {
36204       {
36205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36206       };
36207     } catch (...) {
36208       {
36209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36210       };
36211     }
36212   }
36213
36214   jresult = result;
36215   return jresult;
36216 }
36217
36218
36219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36220   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36221   bool arg2 ;
36222
36223   arg1 = (Dali::Actor *)jarg1;
36224   arg2 = jarg2 ? true : false;
36225   {
36226     try {
36227       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
36228     } catch (std::out_of_range& e) {
36229       {
36230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36231       };
36232     } catch (std::exception& e) {
36233       {
36234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36235       };
36236     } catch (Dali::DaliException e) {
36237       {
36238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36239       };
36240     } catch (...) {
36241       {
36242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36243       };
36244     }
36245   }
36246
36247 }
36248
36249
36250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36251   unsigned int jresult ;
36252   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36253   bool result;
36254
36255   arg1 = (Dali::Actor *)jarg1;
36256   {
36257     try {
36258       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
36259     } catch (std::out_of_range& e) {
36260       {
36261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36262       };
36263     } catch (std::exception& e) {
36264       {
36265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36266       };
36267     } catch (Dali::DaliException e) {
36268       {
36269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36270       };
36271     } catch (...) {
36272       {
36273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36274       };
36275     }
36276   }
36277
36278   jresult = result;
36279   return jresult;
36280 }
36281
36282
36283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36285   Dali::ResizePolicy::Type arg2 ;
36286   Dali::Dimension::Type arg3 ;
36287
36288   arg1 = (Dali::Actor *)jarg1;
36289   arg2 = (Dali::ResizePolicy::Type)jarg2;
36290   arg3 = (Dali::Dimension::Type)jarg3;
36291   {
36292     try {
36293       (arg1)->SetResizePolicy(arg2,arg3);
36294     } catch (std::out_of_range& e) {
36295       {
36296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36297       };
36298     } catch (std::exception& e) {
36299       {
36300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36301       };
36302     } catch (Dali::DaliException e) {
36303       {
36304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36305       };
36306     } catch (...) {
36307       {
36308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36309       };
36310     }
36311   }
36312
36313 }
36314
36315
36316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36317   int jresult ;
36318   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36319   Dali::Dimension::Type arg2 ;
36320   Dali::ResizePolicy::Type result;
36321
36322   arg1 = (Dali::Actor *)jarg1;
36323   arg2 = (Dali::Dimension::Type)jarg2;
36324   {
36325     try {
36326       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36327     } catch (std::out_of_range& e) {
36328       {
36329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36330       };
36331     } catch (std::exception& e) {
36332       {
36333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36334       };
36335     } catch (Dali::DaliException e) {
36336       {
36337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36338       };
36339     } catch (...) {
36340       {
36341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36342       };
36343     }
36344   }
36345
36346   jresult = (int)result;
36347   return jresult;
36348 }
36349
36350
36351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36352   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36353   Dali::SizeScalePolicy::Type arg2 ;
36354
36355   arg1 = (Dali::Actor *)jarg1;
36356   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36357   {
36358     try {
36359       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36360     } catch (std::out_of_range& e) {
36361       {
36362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36363       };
36364     } catch (std::exception& e) {
36365       {
36366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36367       };
36368     } catch (Dali::DaliException e) {
36369       {
36370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36371       };
36372     } catch (...) {
36373       {
36374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36375       };
36376     }
36377   }
36378
36379 }
36380
36381
36382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36383   int jresult ;
36384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36385   Dali::SizeScalePolicy::Type result;
36386
36387   arg1 = (Dali::Actor *)jarg1;
36388   {
36389     try {
36390       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36391     } catch (std::out_of_range& e) {
36392       {
36393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36394       };
36395     } catch (std::exception& e) {
36396       {
36397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36398       };
36399     } catch (Dali::DaliException e) {
36400       {
36401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36402       };
36403     } catch (...) {
36404       {
36405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36406       };
36407     }
36408   }
36409
36410   jresult = (int)result;
36411   return jresult;
36412 }
36413
36414
36415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36417   Dali::Vector3 *arg2 = 0 ;
36418
36419   arg1 = (Dali::Actor *)jarg1;
36420   arg2 = (Dali::Vector3 *)jarg2;
36421   if (!arg2) {
36422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36423     return ;
36424   }
36425   {
36426     try {
36427       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36428     } catch (std::out_of_range& e) {
36429       {
36430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36431       };
36432     } catch (std::exception& e) {
36433       {
36434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36435       };
36436     } catch (Dali::DaliException e) {
36437       {
36438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36439       };
36440     } catch (...) {
36441       {
36442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36443       };
36444     }
36445   }
36446
36447 }
36448
36449
36450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36451   void * jresult ;
36452   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36453   Dali::Vector3 result;
36454
36455   arg1 = (Dali::Actor *)jarg1;
36456   {
36457     try {
36458       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36459     } catch (std::out_of_range& e) {
36460       {
36461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36462       };
36463     } catch (std::exception& e) {
36464       {
36465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36466       };
36467     } catch (Dali::DaliException e) {
36468       {
36469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36470       };
36471     } catch (...) {
36472       {
36473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36474       };
36475     }
36476   }
36477
36478   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36479   return jresult;
36480 }
36481
36482
36483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36484   float jresult ;
36485   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36486   float arg2 ;
36487   float result;
36488
36489   arg1 = (Dali::Actor *)jarg1;
36490   arg2 = (float)jarg2;
36491   {
36492     try {
36493       result = (float)(arg1)->GetHeightForWidth(arg2);
36494     } catch (std::out_of_range& e) {
36495       {
36496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36497       };
36498     } catch (std::exception& e) {
36499       {
36500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36501       };
36502     } catch (Dali::DaliException e) {
36503       {
36504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36505       };
36506     } catch (...) {
36507       {
36508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36509       };
36510     }
36511   }
36512
36513   jresult = result;
36514   return jresult;
36515 }
36516
36517
36518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36519   float jresult ;
36520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36521   float arg2 ;
36522   float result;
36523
36524   arg1 = (Dali::Actor *)jarg1;
36525   arg2 = (float)jarg2;
36526   {
36527     try {
36528       result = (float)(arg1)->GetWidthForHeight(arg2);
36529     } catch (std::out_of_range& e) {
36530       {
36531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36532       };
36533     } catch (std::exception& e) {
36534       {
36535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36536       };
36537     } catch (Dali::DaliException e) {
36538       {
36539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36540       };
36541     } catch (...) {
36542       {
36543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36544       };
36545     }
36546   }
36547
36548   jresult = result;
36549   return jresult;
36550 }
36551
36552
36553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36554   float jresult ;
36555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36556   Dali::Dimension::Type arg2 ;
36557   float result;
36558
36559   arg1 = (Dali::Actor *)jarg1;
36560   arg2 = (Dali::Dimension::Type)jarg2;
36561   {
36562     try {
36563       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36564     } catch (std::out_of_range& e) {
36565       {
36566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36567       };
36568     } catch (std::exception& e) {
36569       {
36570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36571       };
36572     } catch (Dali::DaliException e) {
36573       {
36574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36575       };
36576     } catch (...) {
36577       {
36578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36579       };
36580     }
36581   }
36582
36583   jresult = result;
36584   return jresult;
36585 }
36586
36587
36588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36589   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36590   Dali::Padding *arg2 = 0 ;
36591
36592   arg1 = (Dali::Actor *)jarg1;
36593   arg2 = (Dali::Padding *)jarg2;
36594   if (!arg2) {
36595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36596     return ;
36597   }
36598   {
36599     try {
36600       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36601     } catch (std::out_of_range& e) {
36602       {
36603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36604       };
36605     } catch (std::exception& e) {
36606       {
36607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36608       };
36609     } catch (Dali::DaliException e) {
36610       {
36611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36612       };
36613     } catch (...) {
36614       {
36615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36616       };
36617     }
36618   }
36619
36620 }
36621
36622
36623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36624   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36625   Dali::Padding *arg2 = 0 ;
36626
36627   arg1 = (Dali::Actor *)jarg1;
36628   arg2 = (Dali::Padding *)jarg2;
36629   if (!arg2) {
36630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36631     return ;
36632   }
36633   {
36634     try {
36635       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36636     } catch (std::out_of_range& e) {
36637       {
36638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36639       };
36640     } catch (std::exception& e) {
36641       {
36642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36643       };
36644     } catch (Dali::DaliException e) {
36645       {
36646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36647       };
36648     } catch (...) {
36649       {
36650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36651       };
36652     }
36653   }
36654
36655 }
36656
36657
36658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36660   Dali::Vector2 *arg2 = 0 ;
36661
36662   arg1 = (Dali::Actor *)jarg1;
36663   arg2 = (Dali::Vector2 *)jarg2;
36664   if (!arg2) {
36665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36666     return ;
36667   }
36668   {
36669     try {
36670       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36671     } catch (std::out_of_range& e) {
36672       {
36673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36674       };
36675     } catch (std::exception& e) {
36676       {
36677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36678       };
36679     } catch (Dali::DaliException e) {
36680       {
36681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36682       };
36683     } catch (...) {
36684       {
36685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36686       };
36687     }
36688   }
36689
36690 }
36691
36692
36693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36694   void * jresult ;
36695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36696   Dali::Vector2 result;
36697
36698   arg1 = (Dali::Actor *)jarg1;
36699   {
36700     try {
36701       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36702     } catch (std::out_of_range& e) {
36703       {
36704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36705       };
36706     } catch (std::exception& e) {
36707       {
36708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36709       };
36710     } catch (Dali::DaliException e) {
36711       {
36712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36713       };
36714     } catch (...) {
36715       {
36716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36717       };
36718     }
36719   }
36720
36721   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36722   return jresult;
36723 }
36724
36725
36726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36728   Dali::Vector2 *arg2 = 0 ;
36729
36730   arg1 = (Dali::Actor *)jarg1;
36731   arg2 = (Dali::Vector2 *)jarg2;
36732   if (!arg2) {
36733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36734     return ;
36735   }
36736   {
36737     try {
36738       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36739     } catch (std::out_of_range& e) {
36740       {
36741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36742       };
36743     } catch (std::exception& e) {
36744       {
36745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36746       };
36747     } catch (Dali::DaliException e) {
36748       {
36749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36750       };
36751     } catch (...) {
36752       {
36753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36754       };
36755     }
36756   }
36757
36758 }
36759
36760
36761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36762   void * jresult ;
36763   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36764   Dali::Vector2 result;
36765
36766   arg1 = (Dali::Actor *)jarg1;
36767   {
36768     try {
36769       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
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 = new Dali::Vector2((const Dali::Vector2 &)result);
36790   return jresult;
36791 }
36792
36793
36794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36795   int jresult ;
36796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36797   int result;
36798
36799   arg1 = (Dali::Actor *)jarg1;
36800   {
36801     try {
36802       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36803       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36804     } catch (std::out_of_range& e) {
36805       {
36806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36807       };
36808     } catch (std::exception& e) {
36809       {
36810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36811       };
36812     } catch (Dali::DaliException e) {
36813       {
36814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36815       };
36816     } catch (...) {
36817       {
36818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36819       };
36820     }
36821   }
36822
36823   jresult = result;
36824   return jresult;
36825 }
36826
36827
36828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36829   unsigned int jresult ;
36830   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36831   Dali::Renderer *arg2 = 0 ;
36832   unsigned int result;
36833
36834   arg1 = (Dali::Actor *)jarg1;
36835   arg2 = (Dali::Renderer *)jarg2;
36836   if (!arg2) {
36837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36838     return 0;
36839   }
36840   {
36841     try {
36842       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36843     } catch (std::out_of_range& e) {
36844       {
36845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36846       };
36847     } catch (std::exception& e) {
36848       {
36849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36850       };
36851     } catch (Dali::DaliException e) {
36852       {
36853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36854       };
36855     } catch (...) {
36856       {
36857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36858       };
36859     }
36860   }
36861
36862   jresult = result;
36863   return jresult;
36864 }
36865
36866
36867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36868   unsigned int jresult ;
36869   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36870   unsigned int result;
36871
36872   arg1 = (Dali::Actor *)jarg1;
36873   {
36874     try {
36875       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36876     } catch (std::out_of_range& e) {
36877       {
36878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36879       };
36880     } catch (std::exception& e) {
36881       {
36882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36883       };
36884     } catch (Dali::DaliException e) {
36885       {
36886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36887       };
36888     } catch (...) {
36889       {
36890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36891       };
36892     }
36893   }
36894
36895   jresult = result;
36896   return jresult;
36897 }
36898
36899
36900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36901   void * jresult ;
36902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36903   unsigned int arg2 ;
36904   Dali::Renderer result;
36905
36906   arg1 = (Dali::Actor *)jarg1;
36907   arg2 = (unsigned int)jarg2;
36908   {
36909     try {
36910       result = (arg1)->GetRendererAt(arg2);
36911     } catch (std::out_of_range& e) {
36912       {
36913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36914       };
36915     } catch (std::exception& e) {
36916       {
36917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36918       };
36919     } catch (Dali::DaliException e) {
36920       {
36921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36922       };
36923     } catch (...) {
36924       {
36925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36926       };
36927     }
36928   }
36929
36930   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36931   return jresult;
36932 }
36933
36934
36935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36936   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36937   Dali::Renderer *arg2 = 0 ;
36938
36939   arg1 = (Dali::Actor *)jarg1;
36940   arg2 = (Dali::Renderer *)jarg2;
36941   if (!arg2) {
36942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36943     return ;
36944   }
36945   {
36946     try {
36947       (arg1)->RemoveRenderer(*arg2);
36948     } catch (std::out_of_range& e) {
36949       {
36950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36951       };
36952     } catch (std::exception& e) {
36953       {
36954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36955       };
36956     } catch (Dali::DaliException e) {
36957       {
36958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36959       };
36960     } catch (...) {
36961       {
36962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36963       };
36964     }
36965   }
36966
36967 }
36968
36969
36970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36972   unsigned int arg2 ;
36973
36974   arg1 = (Dali::Actor *)jarg1;
36975   arg2 = (unsigned int)jarg2;
36976   {
36977     try {
36978       (arg1)->RemoveRenderer(arg2);
36979     } catch (std::out_of_range& e) {
36980       {
36981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36982       };
36983     } catch (std::exception& e) {
36984       {
36985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36986       };
36987     } catch (Dali::DaliException e) {
36988       {
36989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36990       };
36991     } catch (...) {
36992       {
36993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36994       };
36995     }
36996   }
36997
36998 }
36999
37000
37001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
37002   void * jresult ;
37003   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37004   Dali::Actor::TouchEventSignalType *result = 0 ;
37005
37006   arg1 = (Dali::Actor *)jarg1;
37007   {
37008     try {
37009       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
37010     } catch (std::out_of_range& e) {
37011       {
37012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37013       };
37014     } catch (std::exception& e) {
37015       {
37016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37017       };
37018     } catch (Dali::DaliException e) {
37019       {
37020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37021       };
37022     } catch (...) {
37023       {
37024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37025       };
37026     }
37027   }
37028
37029   jresult = (void *)result;
37030   return jresult;
37031 }
37032
37033
37034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37035   void * jresult ;
37036   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37037   Dali::Actor::HoverSignalType *result = 0 ;
37038
37039   arg1 = (Dali::Actor *)jarg1;
37040   {
37041     try {
37042       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37043     } catch (std::out_of_range& e) {
37044       {
37045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37046       };
37047     } catch (std::exception& e) {
37048       {
37049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37050       };
37051     } catch (Dali::DaliException e) {
37052       {
37053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37054       };
37055     } catch (...) {
37056       {
37057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37058       };
37059     }
37060   }
37061
37062   jresult = (void *)result;
37063   return jresult;
37064 }
37065
37066
37067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37068   void * jresult ;
37069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37070   Dali::Actor::WheelEventSignalType *result = 0 ;
37071
37072   arg1 = (Dali::Actor *)jarg1;
37073   {
37074     try {
37075       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37076     } catch (std::out_of_range& e) {
37077       {
37078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37079       };
37080     } catch (std::exception& e) {
37081       {
37082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37083       };
37084     } catch (Dali::DaliException e) {
37085       {
37086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37087       };
37088     } catch (...) {
37089       {
37090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37091       };
37092     }
37093   }
37094
37095   jresult = (void *)result;
37096   return jresult;
37097 }
37098
37099
37100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
37101   void * jresult ;
37102   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37103   Dali::Actor::OnSceneSignalType *result = 0 ;
37104
37105   arg1 = (Dali::Actor *)jarg1;
37106   {
37107     try {
37108       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
37109     } catch (std::out_of_range& e) {
37110       {
37111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37112       };
37113     } catch (std::exception& e) {
37114       {
37115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37116       };
37117     } catch (Dali::DaliException e) {
37118       {
37119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37120       };
37121     } catch (...) {
37122       {
37123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37124       };
37125     }
37126   }
37127
37128   jresult = (void *)result;
37129   return jresult;
37130 }
37131
37132
37133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
37134   void * jresult ;
37135   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37136   Dali::Actor::OffSceneSignalType *result = 0 ;
37137
37138   arg1 = (Dali::Actor *)jarg1;
37139   {
37140     try {
37141       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
37142     } catch (std::out_of_range& e) {
37143       {
37144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37145       };
37146     } catch (std::exception& e) {
37147       {
37148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37149       };
37150     } catch (Dali::DaliException e) {
37151       {
37152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37153       };
37154     } catch (...) {
37155       {
37156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37157       };
37158     }
37159   }
37160
37161   jresult = (void *)result;
37162   return jresult;
37163 }
37164
37165
37166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37167   void * jresult ;
37168   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37169   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37170
37171   arg1 = (Dali::Actor *)jarg1;
37172   {
37173     try {
37174       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37175     } catch (std::out_of_range& e) {
37176       {
37177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37178       };
37179     } catch (std::exception& e) {
37180       {
37181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37182       };
37183     } catch (Dali::DaliException e) {
37184       {
37185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37186       };
37187     } catch (...) {
37188       {
37189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37190       };
37191     }
37192   }
37193
37194   jresult = (void *)result;
37195   return jresult;
37196 }
37197
37198
37199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37200   Dali::Actor *arg1 = 0 ;
37201
37202   arg1 = (Dali::Actor *)jarg1;
37203   if (!arg1) {
37204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37205     return ;
37206   }
37207   {
37208     try {
37209       Dali::UnparentAndReset(*arg1);
37210     } catch (std::out_of_range& e) {
37211       {
37212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37213       };
37214     } catch (std::exception& e) {
37215       {
37216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37217       };
37218     } catch (Dali::DaliException e) {
37219       {
37220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37221       };
37222     } catch (...) {
37223       {
37224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37225       };
37226     }
37227   }
37228
37229 }
37230
37231
37232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37233   int jresult ;
37234   int result;
37235
37236   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37237   jresult = (int)result;
37238   return jresult;
37239 }
37240
37241
37242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37243   int jresult ;
37244   int result;
37245
37246   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37247   jresult = (int)result;
37248   return jresult;
37249 }
37250
37251
37252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37253   int jresult ;
37254   int result;
37255
37256   result = (int)Dali::Layer::Property::BEHAVIOR;
37257   jresult = (int)result;
37258   return jresult;
37259 }
37260
37261
37262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37263   void * jresult ;
37264   Dali::Layer::Property *result = 0 ;
37265
37266   {
37267     try {
37268       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37269     } catch (std::out_of_range& e) {
37270       {
37271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37272       };
37273     } catch (std::exception& e) {
37274       {
37275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37276       };
37277     } catch (Dali::DaliException e) {
37278       {
37279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37280       };
37281     } catch (...) {
37282       {
37283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37284       };
37285     }
37286   }
37287
37288   jresult = (void *)result;
37289   return jresult;
37290 }
37291
37292
37293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37294   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37295
37296   arg1 = (Dali::Layer::Property *)jarg1;
37297   {
37298     try {
37299       delete arg1;
37300     } catch (std::out_of_range& e) {
37301       {
37302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37303       };
37304     } catch (std::exception& e) {
37305       {
37306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37307       };
37308     } catch (Dali::DaliException e) {
37309       {
37310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37311       };
37312     } catch (...) {
37313       {
37314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37315       };
37316     }
37317   }
37318
37319 }
37320
37321
37322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37323   void * jresult ;
37324   Dali::Layer *result = 0 ;
37325
37326   {
37327     try {
37328       result = (Dali::Layer *)new Dali::Layer();
37329     } catch (std::out_of_range& e) {
37330       {
37331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37332       };
37333     } catch (std::exception& e) {
37334       {
37335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37336       };
37337     } catch (Dali::DaliException e) {
37338       {
37339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37340       };
37341     } catch (...) {
37342       {
37343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37344       };
37345     }
37346   }
37347
37348   jresult = (void *)result;
37349   return jresult;
37350 }
37351
37352
37353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37354   void * jresult ;
37355   Dali::Layer result;
37356
37357   {
37358     try {
37359       result = Dali::Layer::New();
37360     } catch (std::out_of_range& e) {
37361       {
37362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37363       };
37364     } catch (std::exception& e) {
37365       {
37366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37367       };
37368     } catch (Dali::DaliException e) {
37369       {
37370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37371       };
37372     } catch (...) {
37373       {
37374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37375       };
37376     }
37377   }
37378
37379   jresult = new Dali::Layer((const Dali::Layer &)result);
37380   return jresult;
37381 }
37382
37383
37384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37385   void * jresult ;
37386   Dali::BaseHandle arg1 ;
37387   Dali::BaseHandle *argp1 ;
37388   Dali::Layer result;
37389
37390   argp1 = (Dali::BaseHandle *)jarg1;
37391   if (!argp1) {
37392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37393     return 0;
37394   }
37395   arg1 = *argp1;
37396   {
37397     try {
37398       result = Dali::Layer::DownCast(arg1);
37399     } catch (std::out_of_range& e) {
37400       {
37401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37402       };
37403     } catch (std::exception& e) {
37404       {
37405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37406       };
37407     } catch (Dali::DaliException e) {
37408       {
37409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37410       };
37411     } catch (...) {
37412       {
37413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37414       };
37415     }
37416   }
37417
37418   jresult = new Dali::Layer((const Dali::Layer &)result);
37419   return jresult;
37420 }
37421
37422
37423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37424   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37425
37426   arg1 = (Dali::Layer *)jarg1;
37427   {
37428     try {
37429       delete arg1;
37430     } catch (std::out_of_range& e) {
37431       {
37432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37433       };
37434     } catch (std::exception& e) {
37435       {
37436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37437       };
37438     } catch (Dali::DaliException e) {
37439       {
37440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37441       };
37442     } catch (...) {
37443       {
37444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37445       };
37446     }
37447   }
37448
37449 }
37450
37451
37452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37453   void * jresult ;
37454   Dali::Layer *arg1 = 0 ;
37455   Dali::Layer *result = 0 ;
37456
37457   arg1 = (Dali::Layer *)jarg1;
37458   if (!arg1) {
37459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37460     return 0;
37461   }
37462   {
37463     try {
37464       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37465     } catch (std::out_of_range& e) {
37466       {
37467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37468       };
37469     } catch (std::exception& e) {
37470       {
37471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37472       };
37473     } catch (Dali::DaliException e) {
37474       {
37475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37476       };
37477     } catch (...) {
37478       {
37479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37480       };
37481     }
37482   }
37483
37484   jresult = (void *)result;
37485   return jresult;
37486 }
37487
37488
37489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37490   void * jresult ;
37491   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37492   Dali::Layer *arg2 = 0 ;
37493   Dali::Layer *result = 0 ;
37494
37495   arg1 = (Dali::Layer *)jarg1;
37496   arg2 = (Dali::Layer *)jarg2;
37497   if (!arg2) {
37498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37499     return 0;
37500   }
37501   {
37502     try {
37503       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37504     } catch (std::out_of_range& e) {
37505       {
37506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37507       };
37508     } catch (std::exception& e) {
37509       {
37510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37511       };
37512     } catch (Dali::DaliException e) {
37513       {
37514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37515       };
37516     } catch (...) {
37517       {
37518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37519       };
37520     }
37521   }
37522
37523   jresult = (void *)result;
37524   return jresult;
37525 }
37526
37527
37528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37529   unsigned int jresult ;
37530   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37531   unsigned int result;
37532
37533   arg1 = (Dali::Layer *)jarg1;
37534   {
37535     try {
37536       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37537     } catch (std::out_of_range& e) {
37538       {
37539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37540       };
37541     } catch (std::exception& e) {
37542       {
37543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37544       };
37545     } catch (Dali::DaliException e) {
37546       {
37547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37548       };
37549     } catch (...) {
37550       {
37551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37552       };
37553     }
37554   }
37555
37556   jresult = result;
37557   return jresult;
37558 }
37559
37560
37561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37562   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37563
37564   arg1 = (Dali::Layer *)jarg1;
37565   {
37566     try {
37567       (arg1)->Raise();
37568     } catch (std::out_of_range& e) {
37569       {
37570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37571       };
37572     } catch (std::exception& e) {
37573       {
37574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37575       };
37576     } catch (Dali::DaliException e) {
37577       {
37578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37579       };
37580     } catch (...) {
37581       {
37582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37583       };
37584     }
37585   }
37586
37587 }
37588
37589
37590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37591   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37592
37593   arg1 = (Dali::Layer *)jarg1;
37594   {
37595     try {
37596       (arg1)->Lower();
37597     } catch (std::out_of_range& e) {
37598       {
37599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37600       };
37601     } catch (std::exception& e) {
37602       {
37603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37604       };
37605     } catch (Dali::DaliException e) {
37606       {
37607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37608       };
37609     } catch (...) {
37610       {
37611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37612       };
37613     }
37614   }
37615
37616 }
37617
37618
37619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37620   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37621   Dali::Layer arg2 ;
37622   Dali::Layer *argp2 ;
37623
37624   arg1 = (Dali::Layer *)jarg1;
37625   argp2 = (Dali::Layer *)jarg2;
37626   if (!argp2) {
37627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37628     return ;
37629   }
37630   arg2 = *argp2;
37631   {
37632     try {
37633       (arg1)->RaiseAbove(arg2);
37634     } catch (std::out_of_range& e) {
37635       {
37636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37637       };
37638     } catch (std::exception& e) {
37639       {
37640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37641       };
37642     } catch (Dali::DaliException e) {
37643       {
37644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37645       };
37646     } catch (...) {
37647       {
37648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37649       };
37650     }
37651   }
37652
37653 }
37654
37655
37656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37657   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37658   Dali::Layer arg2 ;
37659   Dali::Layer *argp2 ;
37660
37661   arg1 = (Dali::Layer *)jarg1;
37662   argp2 = (Dali::Layer *)jarg2;
37663   if (!argp2) {
37664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37665     return ;
37666   }
37667   arg2 = *argp2;
37668   {
37669     try {
37670       (arg1)->LowerBelow(arg2);
37671     } catch (std::out_of_range& e) {
37672       {
37673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37674       };
37675     } catch (std::exception& e) {
37676       {
37677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37678       };
37679     } catch (Dali::DaliException e) {
37680       {
37681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37682       };
37683     } catch (...) {
37684       {
37685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37686       };
37687     }
37688   }
37689
37690 }
37691
37692
37693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37694   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37695
37696   arg1 = (Dali::Layer *)jarg1;
37697   {
37698     try {
37699       (arg1)->RaiseToTop();
37700     } catch (std::out_of_range& e) {
37701       {
37702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37703       };
37704     } catch (std::exception& e) {
37705       {
37706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37707       };
37708     } catch (Dali::DaliException e) {
37709       {
37710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37711       };
37712     } catch (...) {
37713       {
37714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37715       };
37716     }
37717   }
37718
37719 }
37720
37721
37722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37723   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37724
37725   arg1 = (Dali::Layer *)jarg1;
37726   {
37727     try {
37728       (arg1)->LowerToBottom();
37729     } catch (std::out_of_range& e) {
37730       {
37731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37732       };
37733     } catch (std::exception& e) {
37734       {
37735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37736       };
37737     } catch (Dali::DaliException e) {
37738       {
37739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37740       };
37741     } catch (...) {
37742       {
37743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37744       };
37745     }
37746   }
37747
37748 }
37749
37750
37751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37752   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37753   Dali::Layer arg2 ;
37754   Dali::Layer *argp2 ;
37755
37756   arg1 = (Dali::Layer *)jarg1;
37757   argp2 = (Dali::Layer *)jarg2;
37758   if (!argp2) {
37759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37760     return ;
37761   }
37762   arg2 = *argp2;
37763   {
37764     try {
37765       (arg1)->MoveAbove(arg2);
37766     } catch (std::out_of_range& e) {
37767       {
37768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37769       };
37770     } catch (std::exception& e) {
37771       {
37772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37773       };
37774     } catch (Dali::DaliException e) {
37775       {
37776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37777       };
37778     } catch (...) {
37779       {
37780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37781       };
37782     }
37783   }
37784
37785 }
37786
37787
37788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37789   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37790   Dali::Layer arg2 ;
37791   Dali::Layer *argp2 ;
37792
37793   arg1 = (Dali::Layer *)jarg1;
37794   argp2 = (Dali::Layer *)jarg2;
37795   if (!argp2) {
37796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37797     return ;
37798   }
37799   arg2 = *argp2;
37800   {
37801     try {
37802       (arg1)->MoveBelow(arg2);
37803     } catch (std::out_of_range& e) {
37804       {
37805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37806       };
37807     } catch (std::exception& e) {
37808       {
37809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37810       };
37811     } catch (Dali::DaliException e) {
37812       {
37813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37814       };
37815     } catch (...) {
37816       {
37817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37818       };
37819     }
37820   }
37821
37822 }
37823
37824
37825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37826   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37827   Dali::Layer::Behavior arg2 ;
37828
37829   arg1 = (Dali::Layer *)jarg1;
37830   arg2 = (Dali::Layer::Behavior)jarg2;
37831   {
37832     try {
37833       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37834     } catch (std::out_of_range& e) {
37835       {
37836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37837       };
37838     } catch (std::exception& e) {
37839       {
37840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37841       };
37842     } catch (Dali::DaliException e) {
37843       {
37844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37845       };
37846     } catch (...) {
37847       {
37848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37849       };
37850     }
37851   }
37852
37853 }
37854
37855
37856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37857   int jresult ;
37858   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37859   Dali::Layer::Behavior result;
37860
37861   arg1 = (Dali::Layer *)jarg1;
37862   {
37863     try {
37864       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37865     } catch (std::out_of_range& e) {
37866       {
37867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37868       };
37869     } catch (std::exception& e) {
37870       {
37871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37872       };
37873     } catch (Dali::DaliException e) {
37874       {
37875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37876       };
37877     } catch (...) {
37878       {
37879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37880       };
37881     }
37882   }
37883
37884   jresult = (int)result;
37885   return jresult;
37886 }
37887
37888
37889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37890   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37891   bool arg2 ;
37892
37893   arg1 = (Dali::Layer *)jarg1;
37894   arg2 = jarg2 ? true : false;
37895   {
37896     try {
37897       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37898     } catch (std::out_of_range& e) {
37899       {
37900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37901       };
37902     } catch (std::exception& e) {
37903       {
37904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37905       };
37906     } catch (Dali::DaliException e) {
37907       {
37908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37909       };
37910     } catch (...) {
37911       {
37912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37913       };
37914     }
37915   }
37916
37917 }
37918
37919
37920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37921   unsigned int jresult ;
37922   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37923   bool result;
37924
37925   arg1 = (Dali::Layer *)jarg1;
37926   {
37927     try {
37928       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37929     } catch (std::out_of_range& e) {
37930       {
37931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37932       };
37933     } catch (std::exception& e) {
37934       {
37935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37936       };
37937     } catch (Dali::DaliException e) {
37938       {
37939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37940       };
37941     } catch (...) {
37942       {
37943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37944       };
37945     }
37946   }
37947
37948   jresult = result;
37949   return jresult;
37950 }
37951
37952
37953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37954   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37955   int arg2 ;
37956   int arg3 ;
37957   int arg4 ;
37958   int arg5 ;
37959
37960   arg1 = (Dali::Layer *)jarg1;
37961   arg2 = (int)jarg2;
37962   arg3 = (int)jarg3;
37963   arg4 = (int)jarg4;
37964   arg5 = (int)jarg5;
37965   {
37966     try {
37967       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37968     } catch (std::out_of_range& e) {
37969       {
37970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37971       };
37972     } catch (std::exception& e) {
37973       {
37974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37975       };
37976     } catch (Dali::DaliException e) {
37977       {
37978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37979       };
37980     } catch (...) {
37981       {
37982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37983       };
37984     }
37985   }
37986
37987 }
37988
37989
37990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37991   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37992   Dali::ClippingBox arg2 ;
37993   Dali::ClippingBox *argp2 ;
37994
37995   arg1 = (Dali::Layer *)jarg1;
37996   argp2 = (Dali::ClippingBox *)jarg2;
37997   if (!argp2) {
37998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37999     return ;
38000   }
38001   arg2 = *argp2;
38002   {
38003     try {
38004       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
38005     } catch (std::out_of_range& e) {
38006       {
38007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38008       };
38009     } catch (std::exception& e) {
38010       {
38011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38012       };
38013     } catch (Dali::DaliException e) {
38014       {
38015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38016       };
38017     } catch (...) {
38018       {
38019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38020       };
38021     }
38022   }
38023
38024 }
38025
38026
38027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38028   void * jresult ;
38029   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38030   Dali::ClippingBox result;
38031
38032   arg1 = (Dali::Layer *)jarg1;
38033   {
38034     try {
38035       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
38036     } catch (std::out_of_range& e) {
38037       {
38038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38039       };
38040     } catch (std::exception& e) {
38041       {
38042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38043       };
38044     } catch (Dali::DaliException e) {
38045       {
38046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38047       };
38048     } catch (...) {
38049       {
38050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38051       };
38052     }
38053   }
38054
38055   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38056   return jresult;
38057 }
38058
38059
38060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38061   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38062   bool arg2 ;
38063
38064   arg1 = (Dali::Layer *)jarg1;
38065   arg2 = jarg2 ? true : false;
38066   {
38067     try {
38068       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
38069     } catch (std::out_of_range& e) {
38070       {
38071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38072       };
38073     } catch (std::exception& e) {
38074       {
38075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38076       };
38077     } catch (Dali::DaliException e) {
38078       {
38079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38080       };
38081     } catch (...) {
38082       {
38083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38084       };
38085     }
38086   }
38087
38088 }
38089
38090
38091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38092   unsigned int jresult ;
38093   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38094   bool result;
38095
38096   arg1 = (Dali::Layer *)jarg1;
38097   {
38098     try {
38099       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
38100     } catch (std::out_of_range& e) {
38101       {
38102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38103       };
38104     } catch (std::exception& e) {
38105       {
38106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38107       };
38108     } catch (Dali::DaliException e) {
38109       {
38110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38111       };
38112     } catch (...) {
38113       {
38114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38115       };
38116     }
38117   }
38118
38119   jresult = result;
38120   return jresult;
38121 }
38122
38123
38124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38125   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38126   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38127
38128   arg1 = (Dali::Layer *)jarg1;
38129   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38130   {
38131     try {
38132       (arg1)->SetSortFunction(arg2);
38133     } catch (std::out_of_range& e) {
38134       {
38135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38136       };
38137     } catch (std::exception& e) {
38138       {
38139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38140       };
38141     } catch (Dali::DaliException e) {
38142       {
38143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38144       };
38145     } catch (...) {
38146       {
38147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38148       };
38149     }
38150   }
38151
38152 }
38153
38154
38155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38156   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38157   bool arg2 ;
38158
38159   arg1 = (Dali::Layer *)jarg1;
38160   arg2 = jarg2 ? true : false;
38161   {
38162     try {
38163       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
38164     } catch (std::out_of_range& e) {
38165       {
38166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38167       };
38168     } catch (std::exception& e) {
38169       {
38170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38171       };
38172     } catch (Dali::DaliException e) {
38173       {
38174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38175       };
38176     } catch (...) {
38177       {
38178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38179       };
38180     }
38181   }
38182
38183 }
38184
38185
38186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38187   unsigned int jresult ;
38188   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38189   bool result;
38190
38191   arg1 = (Dali::Layer *)jarg1;
38192   {
38193     try {
38194       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
38195     } catch (std::out_of_range& e) {
38196       {
38197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38198       };
38199     } catch (std::exception& e) {
38200       {
38201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38202       };
38203     } catch (Dali::DaliException e) {
38204       {
38205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38206       };
38207     } catch (...) {
38208       {
38209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38210       };
38211     }
38212   }
38213
38214   jresult = result;
38215   return jresult;
38216 }
38217
38218
38219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38220   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38221   bool arg2 ;
38222
38223   arg1 = (Dali::Layer *)jarg1;
38224   arg2 = jarg2 ? true : false;
38225   {
38226     try {
38227       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
38228     } catch (std::out_of_range& e) {
38229       {
38230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38231       };
38232     } catch (std::exception& e) {
38233       {
38234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38235       };
38236     } catch (Dali::DaliException e) {
38237       {
38238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38239       };
38240     } catch (...) {
38241       {
38242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38243       };
38244     }
38245   }
38246
38247 }
38248
38249
38250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38251   unsigned int jresult ;
38252   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38253   bool result;
38254
38255   arg1 = (Dali::Layer *)jarg1;
38256   {
38257     try {
38258       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
38259     } catch (std::out_of_range& e) {
38260       {
38261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38262       };
38263     } catch (std::exception& e) {
38264       {
38265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38266       };
38267     } catch (Dali::DaliException e) {
38268       {
38269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38270       };
38271     } catch (...) {
38272       {
38273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38274       };
38275     }
38276   }
38277
38278   jresult = result;
38279   return jresult;
38280 }
38281
38282
38283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38284   void * jresult ;
38285   Dali::Stage result;
38286
38287   {
38288     try {
38289       result = Dali::Stage::GetCurrent();
38290     } catch (std::out_of_range& e) {
38291       {
38292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38293       };
38294     } catch (std::exception& e) {
38295       {
38296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38297       };
38298     } catch (Dali::DaliException e) {
38299       {
38300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38301       };
38302     } catch (...) {
38303       {
38304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38305       };
38306     }
38307   }
38308
38309   jresult = new Dali::Stage((const Dali::Stage &)result);
38310   return jresult;
38311 }
38312
38313
38314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38315   unsigned int jresult ;
38316   bool result;
38317
38318   {
38319     try {
38320       result = (bool)Dali::Stage::IsInstalled();
38321     } catch (std::out_of_range& e) {
38322       {
38323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38324       };
38325     } catch (std::exception& e) {
38326       {
38327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38328       };
38329     } catch (Dali::DaliException e) {
38330       {
38331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38332       };
38333     } catch (...) {
38334       {
38335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38336       };
38337     }
38338   }
38339
38340   jresult = result;
38341   return jresult;
38342 }
38343
38344
38345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38346   void * jresult ;
38347   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38348   Dali::Vector2 result;
38349
38350   arg1 = (Dali::Stage *)jarg1;
38351   {
38352     try {
38353       result = ((Dali::Stage const *)arg1)->GetDpi();
38354     } catch (std::out_of_range& e) {
38355       {
38356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38357       };
38358     } catch (std::exception& e) {
38359       {
38360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38361       };
38362     } catch (Dali::DaliException e) {
38363       {
38364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38365       };
38366     } catch (...) {
38367       {
38368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38369       };
38370     }
38371   }
38372
38373   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38374   return jresult;
38375 }
38376
38377
38378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38379   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38380   float arg2 ;
38381
38382   arg1 = (Dali::Stage *)jarg1;
38383   arg2 = (float)jarg2;
38384   {
38385     try {
38386       (arg1)->KeepRendering(arg2);
38387     } catch (std::out_of_range& e) {
38388       {
38389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38390       };
38391     } catch (std::exception& e) {
38392       {
38393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38394       };
38395     } catch (Dali::DaliException e) {
38396       {
38397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38398       };
38399     } catch (...) {
38400       {
38401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38402       };
38403     }
38404   }
38405
38406 }
38407
38408
38409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38410   void * jresult ;
38411   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38412   Dali::Stage::KeyEventSignalType *result = 0 ;
38413
38414   arg1 = (Dali::Stage *)jarg1;
38415   {
38416     try {
38417       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38418     } catch (std::out_of_range& e) {
38419       {
38420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38421       };
38422     } catch (std::exception& e) {
38423       {
38424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38425       };
38426     } catch (Dali::DaliException e) {
38427       {
38428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38429       };
38430     } catch (...) {
38431       {
38432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38433       };
38434     }
38435   }
38436
38437   jresult = (void *)result;
38438   return jresult;
38439 }
38440
38441
38442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38443   void * jresult ;
38444   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38445   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38446
38447   arg1 = (Dali::Stage *)jarg1;
38448   {
38449     try {
38450       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38451     } catch (std::out_of_range& e) {
38452       {
38453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38454       };
38455     } catch (std::exception& e) {
38456       {
38457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38458       };
38459     } catch (Dali::DaliException e) {
38460       {
38461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38462       };
38463     } catch (...) {
38464       {
38465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38466       };
38467     }
38468   }
38469
38470   jresult = (void *)result;
38471   return jresult;
38472 }
38473
38474
38475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38476   void * jresult ;
38477   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38478   Dali::Stage::TouchSignalType *result = 0 ;
38479
38480   arg1 = (Dali::Stage *)jarg1;
38481   {
38482     try {
38483       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38484     } catch (std::out_of_range& e) {
38485       {
38486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38487       };
38488     } catch (std::exception& e) {
38489       {
38490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38491       };
38492     } catch (Dali::DaliException e) {
38493       {
38494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38495       };
38496     } catch (...) {
38497       {
38498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38499       };
38500     }
38501   }
38502
38503   jresult = (void *)result;
38504   return jresult;
38505 }
38506
38507
38508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38509   void * jresult ;
38510   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38511   Dali::Stage::WheelEventSignalType *result = 0 ;
38512
38513   arg1 = (Dali::Stage *)jarg1;
38514   {
38515     try {
38516       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38517     } catch (std::out_of_range& e) {
38518       {
38519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38520       };
38521     } catch (std::exception& e) {
38522       {
38523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38524       };
38525     } catch (Dali::DaliException e) {
38526       {
38527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38528       };
38529     } catch (...) {
38530       {
38531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38532       };
38533     }
38534   }
38535
38536   jresult = (void *)result;
38537   return jresult;
38538 }
38539
38540
38541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38542   void * jresult ;
38543   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38544   Dali::Stage::ContextStatusSignal *result = 0 ;
38545
38546   arg1 = (Dali::Stage *)jarg1;
38547   {
38548     try {
38549       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38550     } catch (std::out_of_range& e) {
38551       {
38552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38553       };
38554     } catch (std::exception& e) {
38555       {
38556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38557       };
38558     } catch (Dali::DaliException e) {
38559       {
38560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38561       };
38562     } catch (...) {
38563       {
38564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38565       };
38566     }
38567   }
38568
38569   jresult = (void *)result;
38570   return jresult;
38571 }
38572
38573
38574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38575   void * jresult ;
38576   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38577   Dali::Stage::ContextStatusSignal *result = 0 ;
38578
38579   arg1 = (Dali::Stage *)jarg1;
38580   {
38581     try {
38582       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38583     } catch (std::out_of_range& e) {
38584       {
38585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38586       };
38587     } catch (std::exception& e) {
38588       {
38589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38590       };
38591     } catch (Dali::DaliException e) {
38592       {
38593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38594       };
38595     } catch (...) {
38596       {
38597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38598       };
38599     }
38600   }
38601
38602   jresult = (void *)result;
38603   return jresult;
38604 }
38605
38606
38607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38608   void * jresult ;
38609   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38610   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38611
38612   arg1 = (Dali::Stage *)jarg1;
38613   {
38614     try {
38615       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38616     } catch (std::out_of_range& e) {
38617       {
38618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38619       };
38620     } catch (std::exception& e) {
38621       {
38622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38623       };
38624     } catch (Dali::DaliException e) {
38625       {
38626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38627       };
38628     } catch (...) {
38629       {
38630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38631       };
38632     }
38633   }
38634
38635   jresult = (void *)result;
38636   return jresult;
38637 }
38638
38639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38640   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38641   Dali::DevelStage::Rendering arg2 ;
38642
38643   arg1 = (Dali::Stage *)jarg1;
38644   arg2 = (Dali::DevelStage::Rendering)jarg2;
38645   {
38646     try {
38647       DevelStage::SetRenderingBehavior(*arg1,arg2);
38648     } catch (std::out_of_range& e) {
38649       {
38650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38651       };
38652     } catch (std::exception& e) {
38653       {
38654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38655       };
38656     } catch (Dali::DaliException e) {
38657       {
38658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38659       };
38660     } catch (...) {
38661       {
38662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38663       };
38664     }
38665   }
38666
38667 }
38668
38669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38670
38671   int jresult ;
38672   int result ;
38673   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38674
38675   arg1 = (Dali::Stage *)jarg1;
38676   {
38677     try {
38678       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38679     } catch (std::out_of_range& e) {
38680       {
38681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38682       };
38683     } catch (std::exception& e) {
38684       {
38685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38686       };
38687     } catch (Dali::DaliException e) {
38688       {
38689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38690       };
38691     } catch (...) {
38692       {
38693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38694       };
38695     }
38696   }
38697
38698   jresult = result;
38699   return jresult;
38700 }
38701
38702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38703   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38704
38705   arg1 = (Dali::RelayoutContainer *)jarg1;
38706   {
38707     try {
38708       delete arg1;
38709     } catch (std::out_of_range& e) {
38710       {
38711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38712       };
38713     } catch (std::exception& e) {
38714       {
38715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38716       };
38717     } catch (Dali::DaliException e) {
38718       {
38719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38720       };
38721     } catch (...) {
38722       {
38723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38724       };
38725     }
38726   }
38727
38728 }
38729
38730
38731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38732   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38733   Dali::Actor *arg2 = 0 ;
38734   Dali::Vector2 *arg3 = 0 ;
38735
38736   arg1 = (Dali::RelayoutContainer *)jarg1;
38737   arg2 = (Dali::Actor *)jarg2;
38738   if (!arg2) {
38739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38740     return ;
38741   }
38742   arg3 = (Dali::Vector2 *)jarg3;
38743   if (!arg3) {
38744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38745     return ;
38746   }
38747   {
38748     try {
38749       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38750     } catch (std::out_of_range& e) {
38751       {
38752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38753       };
38754     } catch (std::exception& e) {
38755       {
38756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38757       };
38758     } catch (Dali::DaliException e) {
38759       {
38760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38761       };
38762     } catch (...) {
38763       {
38764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38765       };
38766     }
38767   }
38768
38769 }
38770
38771
38772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38773   void * jresult ;
38774   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38775   Dali::CustomActor result;
38776
38777   arg1 = (Dali::CustomActorImpl *)jarg1;
38778   {
38779     try {
38780       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38781     } catch (std::out_of_range& e) {
38782       {
38783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38784       };
38785     } catch (std::exception& e) {
38786       {
38787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38788       };
38789     } catch (Dali::DaliException e) {
38790       {
38791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38792       };
38793     } catch (...) {
38794       {
38795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38796       };
38797     }
38798   }
38799
38800   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38801   return jresult;
38802 }
38803
38804
38805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38806   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38807   int arg2 ;
38808
38809   arg1 = (Dali::CustomActorImpl *)jarg1;
38810   arg2 = (int)jarg2;
38811   {
38812     try {
38813       (arg1)->OnSceneConnection(arg2);
38814     } catch (std::out_of_range& e) {
38815       {
38816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38817       };
38818     } catch (std::exception& e) {
38819       {
38820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38821       };
38822     } catch (Dali::DaliException e) {
38823       {
38824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38825       };
38826     } catch (...) {
38827       {
38828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38829       };
38830     }
38831   }
38832
38833 }
38834
38835
38836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
38837   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38838
38839   arg1 = (Dali::CustomActorImpl *)jarg1;
38840   {
38841     try {
38842       (arg1)->OnSceneDisconnection();
38843     } catch (std::out_of_range& e) {
38844       {
38845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38846       };
38847     } catch (std::exception& e) {
38848       {
38849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38850       };
38851     } catch (Dali::DaliException e) {
38852       {
38853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38854       };
38855     } catch (...) {
38856       {
38857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38858       };
38859     }
38860   }
38861
38862 }
38863
38864
38865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
38866   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38867   Dali::Actor *arg2 = 0 ;
38868
38869   arg1 = (Dali::CustomActorImpl *)jarg1;
38870   arg2 = (Dali::Actor *)jarg2;
38871   if (!arg2) {
38872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38873     return ;
38874   }
38875   {
38876     try {
38877       (arg1)->OnChildAdd(*arg2);
38878     } catch (std::out_of_range& e) {
38879       {
38880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38881       };
38882     } catch (std::exception& e) {
38883       {
38884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38885       };
38886     } catch (Dali::DaliException e) {
38887       {
38888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38889       };
38890     } catch (...) {
38891       {
38892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38893       };
38894     }
38895   }
38896
38897 }
38898
38899
38900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
38901   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38902   Dali::Actor *arg2 = 0 ;
38903
38904   arg1 = (Dali::CustomActorImpl *)jarg1;
38905   arg2 = (Dali::Actor *)jarg2;
38906   if (!arg2) {
38907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38908     return ;
38909   }
38910   {
38911     try {
38912       (arg1)->OnChildRemove(*arg2);
38913     } catch (std::out_of_range& e) {
38914       {
38915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38916       };
38917     } catch (std::exception& e) {
38918       {
38919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38920       };
38921     } catch (Dali::DaliException e) {
38922       {
38923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38924       };
38925     } catch (...) {
38926       {
38927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38928       };
38929     }
38930   }
38931
38932 }
38933
38934
38935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38936   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38937   Dali::Property::Index arg2 ;
38938   Dali::Property::Value arg3 ;
38939   Dali::Property::Value *argp3 ;
38940
38941   arg1 = (Dali::CustomActorImpl *)jarg1;
38942   arg2 = (Dali::Property::Index)jarg2;
38943   argp3 = (Dali::Property::Value *)jarg3;
38944   if (!argp3) {
38945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38946     return ;
38947   }
38948   arg3 = *argp3;
38949   {
38950     try {
38951       (arg1)->OnPropertySet(arg2,arg3);
38952     } catch (std::out_of_range& e) {
38953       {
38954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38955       };
38956     } catch (std::exception& e) {
38957       {
38958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38959       };
38960     } catch (Dali::DaliException e) {
38961       {
38962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38963       };
38964     } catch (...) {
38965       {
38966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38967       };
38968     }
38969   }
38970
38971 }
38972
38973
38974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
38975   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38976   Dali::Vector3 *arg2 = 0 ;
38977
38978   arg1 = (Dali::CustomActorImpl *)jarg1;
38979   arg2 = (Dali::Vector3 *)jarg2;
38980   if (!arg2) {
38981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38982     return ;
38983   }
38984   {
38985     try {
38986       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
38987     } catch (std::out_of_range& e) {
38988       {
38989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38990       };
38991     } catch (std::exception& e) {
38992       {
38993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38994       };
38995     } catch (Dali::DaliException e) {
38996       {
38997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38998       };
38999     } catch (...) {
39000       {
39001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39002       };
39003     }
39004   }
39005
39006 }
39007
39008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39009   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39010   Dali::Animation *arg2 = 0 ;
39011   Dali::Vector3 *arg3 = 0 ;
39012
39013   arg1 = (Dali::CustomActorImpl *)jarg1;
39014   arg2 = (Dali::Animation *)jarg2;
39015   if (!arg2) {
39016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39017     return ;
39018   }
39019   arg3 = (Dali::Vector3 *)jarg3;
39020   if (!arg3) {
39021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39022     return ;
39023   }
39024   {
39025     try {
39026       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39027     } catch (std::out_of_range& e) {
39028       {
39029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39030       };
39031     } catch (std::exception& e) {
39032       {
39033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39034       };
39035     } catch (Dali::DaliException e) {
39036       {
39037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39038       };
39039     } catch (...) {
39040       {
39041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39042       };
39043     }
39044   }
39045 }
39046
39047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39048   unsigned int jresult ;
39049   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39050   Dali::HoverEvent *arg2 = 0 ;
39051   bool result;
39052
39053   arg1 = (Dali::CustomActorImpl *)jarg1;
39054   arg2 = (Dali::HoverEvent *)jarg2;
39055   if (!arg2) {
39056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39057     return 0;
39058   }
39059   {
39060     try {
39061       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39062     } catch (std::out_of_range& e) {
39063       {
39064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39065       };
39066     } catch (std::exception& e) {
39067       {
39068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39069       };
39070     } catch (Dali::DaliException e) {
39071       {
39072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39073       };
39074     } catch (...) {
39075       {
39076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39077       };
39078     }
39079   }
39080
39081   jresult = result;
39082   return jresult;
39083 }
39084
39085
39086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39087   unsigned int jresult ;
39088   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39089   Dali::KeyEvent *arg2 = 0 ;
39090   bool result;
39091
39092   arg1 = (Dali::CustomActorImpl *)jarg1;
39093   arg2 = (Dali::KeyEvent *)jarg2;
39094   if (!arg2) {
39095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39096     return 0;
39097   }
39098   {
39099     try {
39100       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39101     } catch (std::out_of_range& e) {
39102       {
39103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39104       };
39105     } catch (std::exception& e) {
39106       {
39107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39108       };
39109     } catch (Dali::DaliException e) {
39110       {
39111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39112       };
39113     } catch (...) {
39114       {
39115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39116       };
39117     }
39118   }
39119
39120   jresult = result;
39121   return jresult;
39122 }
39123
39124
39125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39126   unsigned int jresult ;
39127   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39128   Dali::WheelEvent *arg2 = 0 ;
39129   bool result;
39130
39131   arg1 = (Dali::CustomActorImpl *)jarg1;
39132   arg2 = (Dali::WheelEvent *)jarg2;
39133   if (!arg2) {
39134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39135     return 0;
39136   }
39137   {
39138     try {
39139       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39140     } catch (std::out_of_range& e) {
39141       {
39142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39143       };
39144     } catch (std::exception& e) {
39145       {
39146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39147       };
39148     } catch (Dali::DaliException e) {
39149       {
39150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39151       };
39152     } catch (...) {
39153       {
39154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39155       };
39156     }
39157   }
39158
39159   jresult = result;
39160   return jresult;
39161 }
39162
39163
39164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39165   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39166   Dali::Vector2 *arg2 = 0 ;
39167   Dali::RelayoutContainer *arg3 = 0 ;
39168
39169   arg1 = (Dali::CustomActorImpl *)jarg1;
39170   arg2 = (Dali::Vector2 *)jarg2;
39171   if (!arg2) {
39172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39173     return ;
39174   }
39175   arg3 = (Dali::RelayoutContainer *)jarg3;
39176   if (!arg3) {
39177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39178     return ;
39179   }
39180   {
39181     try {
39182       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39183     } catch (std::out_of_range& e) {
39184       {
39185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39186       };
39187     } catch (std::exception& e) {
39188       {
39189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39190       };
39191     } catch (Dali::DaliException e) {
39192       {
39193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39194       };
39195     } catch (...) {
39196       {
39197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39198       };
39199     }
39200   }
39201
39202 }
39203
39204
39205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39206   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39207   Dali::ResizePolicy::Type arg2 ;
39208   Dali::Dimension::Type arg3 ;
39209
39210   arg1 = (Dali::CustomActorImpl *)jarg1;
39211   arg2 = (Dali::ResizePolicy::Type)jarg2;
39212   arg3 = (Dali::Dimension::Type)jarg3;
39213   {
39214     try {
39215       (arg1)->OnSetResizePolicy(arg2,arg3);
39216     } catch (std::out_of_range& e) {
39217       {
39218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39219       };
39220     } catch (std::exception& e) {
39221       {
39222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39223       };
39224     } catch (Dali::DaliException e) {
39225       {
39226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39227       };
39228     } catch (...) {
39229       {
39230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39231       };
39232     }
39233   }
39234
39235 }
39236
39237
39238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39239   void * jresult ;
39240   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39241   Dali::Vector3 result;
39242
39243   arg1 = (Dali::CustomActorImpl *)jarg1;
39244   {
39245     try {
39246       result = (arg1)->GetNaturalSize();
39247     } catch (std::out_of_range& e) {
39248       {
39249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39250       };
39251     } catch (std::exception& e) {
39252       {
39253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39254       };
39255     } catch (Dali::DaliException e) {
39256       {
39257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39258       };
39259     } catch (...) {
39260       {
39261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39262       };
39263     }
39264   }
39265
39266   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39267   return jresult;
39268 }
39269
39270
39271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39272   float jresult ;
39273   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39274   Dali::Actor *arg2 = 0 ;
39275   Dali::Dimension::Type arg3 ;
39276   float result;
39277
39278   arg1 = (Dali::CustomActorImpl *)jarg1;
39279   arg2 = (Dali::Actor *)jarg2;
39280   if (!arg2) {
39281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39282     return 0;
39283   }
39284   arg3 = (Dali::Dimension::Type)jarg3;
39285   {
39286     try {
39287       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39288     } catch (std::out_of_range& e) {
39289       {
39290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39291       };
39292     } catch (std::exception& e) {
39293       {
39294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39295       };
39296     } catch (Dali::DaliException e) {
39297       {
39298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39299       };
39300     } catch (...) {
39301       {
39302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39303       };
39304     }
39305   }
39306
39307   jresult = result;
39308   return jresult;
39309 }
39310
39311
39312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39313   float jresult ;
39314   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39315   float arg2 ;
39316   float result;
39317
39318   arg1 = (Dali::CustomActorImpl *)jarg1;
39319   arg2 = (float)jarg2;
39320   {
39321     try {
39322       result = (float)(arg1)->GetHeightForWidth(arg2);
39323     } catch (std::out_of_range& e) {
39324       {
39325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39326       };
39327     } catch (std::exception& e) {
39328       {
39329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39330       };
39331     } catch (Dali::DaliException e) {
39332       {
39333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39334       };
39335     } catch (...) {
39336       {
39337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39338       };
39339     }
39340   }
39341
39342   jresult = result;
39343   return jresult;
39344 }
39345
39346
39347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39348   float jresult ;
39349   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39350   float arg2 ;
39351   float result;
39352
39353   arg1 = (Dali::CustomActorImpl *)jarg1;
39354   arg2 = (float)jarg2;
39355   {
39356     try {
39357       result = (float)(arg1)->GetWidthForHeight(arg2);
39358     } catch (std::out_of_range& e) {
39359       {
39360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39361       };
39362     } catch (std::exception& e) {
39363       {
39364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39365       };
39366     } catch (Dali::DaliException e) {
39367       {
39368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39369       };
39370     } catch (...) {
39371       {
39372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39373       };
39374     }
39375   }
39376
39377   jresult = result;
39378   return jresult;
39379 }
39380
39381
39382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39383   unsigned int jresult ;
39384   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39385   Dali::Dimension::Type arg2 ;
39386   bool result;
39387
39388   arg1 = (Dali::CustomActorImpl *)jarg1;
39389   arg2 = (Dali::Dimension::Type)jarg2;
39390   {
39391     try {
39392       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39393     } catch (std::out_of_range& e) {
39394       {
39395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39396       };
39397     } catch (std::exception& e) {
39398       {
39399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39400       };
39401     } catch (Dali::DaliException e) {
39402       {
39403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39404       };
39405     } catch (...) {
39406       {
39407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39408       };
39409     }
39410   }
39411
39412   jresult = result;
39413   return jresult;
39414 }
39415
39416
39417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39418   unsigned int jresult ;
39419   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39420   bool result;
39421
39422   arg1 = (Dali::CustomActorImpl *)jarg1;
39423   {
39424     try {
39425       result = (bool)(arg1)->RelayoutDependentOnChildren();
39426     } catch (std::out_of_range& e) {
39427       {
39428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39429       };
39430     } catch (std::exception& e) {
39431       {
39432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39433       };
39434     } catch (Dali::DaliException e) {
39435       {
39436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39437       };
39438     } catch (...) {
39439       {
39440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39441       };
39442     }
39443   }
39444
39445   jresult = result;
39446   return jresult;
39447 }
39448
39449
39450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39451   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39452   Dali::Dimension::Type arg2 ;
39453
39454   arg1 = (Dali::CustomActorImpl *)jarg1;
39455   arg2 = (Dali::Dimension::Type)jarg2;
39456   {
39457     try {
39458       (arg1)->OnCalculateRelayoutSize(arg2);
39459     } catch (std::out_of_range& e) {
39460       {
39461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39462       };
39463     } catch (std::exception& e) {
39464       {
39465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39466       };
39467     } catch (Dali::DaliException e) {
39468       {
39469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39470       };
39471     } catch (...) {
39472       {
39473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39474       };
39475     }
39476   }
39477
39478 }
39479
39480
39481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39482   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39483   float arg2 ;
39484   Dali::Dimension::Type arg3 ;
39485
39486   arg1 = (Dali::CustomActorImpl *)jarg1;
39487   arg2 = (float)jarg2;
39488   arg3 = (Dali::Dimension::Type)jarg3;
39489   {
39490     try {
39491       (arg1)->OnLayoutNegotiated(arg2,arg3);
39492     } catch (std::out_of_range& e) {
39493       {
39494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39495       };
39496     } catch (std::exception& e) {
39497       {
39498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39499       };
39500     } catch (Dali::DaliException e) {
39501       {
39502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39503       };
39504     } catch (...) {
39505       {
39506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39507       };
39508     }
39509   }
39510
39511 }
39512
39513
39514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39515   unsigned int jresult ;
39516   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39517   bool result;
39518
39519   arg1 = (Dali::CustomActorImpl *)jarg1;
39520   {
39521     try {
39522       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39523     } catch (std::out_of_range& e) {
39524       {
39525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39526       };
39527     } catch (std::exception& e) {
39528       {
39529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39530       };
39531     } catch (Dali::DaliException e) {
39532       {
39533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39534       };
39535     } catch (...) {
39536       {
39537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39538       };
39539     }
39540   }
39541
39542   jresult = result;
39543   return jresult;
39544 }
39545
39546
39547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39548   unsigned int jresult ;
39549   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39550   bool result;
39551
39552   arg1 = (Dali::CustomActorImpl *)jarg1;
39553   {
39554     try {
39555       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39556     } catch (std::out_of_range& e) {
39557       {
39558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39559       };
39560     } catch (std::exception& e) {
39561       {
39562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39563       };
39564     } catch (Dali::DaliException e) {
39565       {
39566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39567       };
39568     } catch (...) {
39569       {
39570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39571       };
39572     }
39573   }
39574
39575   jresult = result;
39576   return jresult;
39577 }
39578
39579
39580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39581   unsigned int jresult ;
39582   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39583   bool result;
39584
39585   arg1 = (Dali::CustomActorImpl *)jarg1;
39586   {
39587     try {
39588       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39589     } catch (std::out_of_range& e) {
39590       {
39591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39592       };
39593     } catch (std::exception& e) {
39594       {
39595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39596       };
39597     } catch (Dali::DaliException e) {
39598       {
39599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39600       };
39601     } catch (...) {
39602       {
39603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39604       };
39605     }
39606   }
39607
39608   jresult = result;
39609   return jresult;
39610 }
39611
39612
39613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39614   unsigned int jresult ;
39615   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39616   bool result;
39617
39618   arg1 = (Dali::CustomActorImpl *)jarg1;
39619   {
39620     try {
39621       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39622     } catch (std::out_of_range& e) {
39623       {
39624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39625       };
39626     } catch (std::exception& e) {
39627       {
39628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39629       };
39630     } catch (Dali::DaliException e) {
39631       {
39632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39633       };
39634     } catch (...) {
39635       {
39636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39637       };
39638     }
39639   }
39640
39641   jresult = result;
39642   return jresult;
39643 }
39644
39645
39646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39647   void * jresult ;
39648   Dali::CustomActor *result = 0 ;
39649
39650   {
39651     try {
39652       result = (Dali::CustomActor *)new Dali::CustomActor();
39653     } catch (std::out_of_range& e) {
39654       {
39655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39656       };
39657     } catch (std::exception& e) {
39658       {
39659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39660       };
39661     } catch (Dali::DaliException e) {
39662       {
39663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39664       };
39665     } catch (...) {
39666       {
39667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39668       };
39669     }
39670   }
39671
39672   jresult = (void *)result;
39673   return jresult;
39674 }
39675
39676
39677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39678   void * jresult ;
39679   Dali::BaseHandle arg1 ;
39680   Dali::BaseHandle *argp1 ;
39681   Dali::CustomActor result;
39682
39683   argp1 = (Dali::BaseHandle *)jarg1;
39684   if (!argp1) {
39685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39686     return 0;
39687   }
39688   arg1 = *argp1;
39689   {
39690     try {
39691       result = Dali::CustomActor::DownCast(arg1);
39692     } catch (std::out_of_range& e) {
39693       {
39694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39695       };
39696     } catch (std::exception& e) {
39697       {
39698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39699       };
39700     } catch (Dali::DaliException e) {
39701       {
39702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39703       };
39704     } catch (...) {
39705       {
39706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39707       };
39708     }
39709   }
39710
39711   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39712   return jresult;
39713 }
39714
39715
39716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39717   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39718
39719   arg1 = (Dali::CustomActor *)jarg1;
39720   {
39721     try {
39722       delete arg1;
39723     } catch (std::out_of_range& e) {
39724       {
39725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39726       };
39727     } catch (std::exception& e) {
39728       {
39729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39730       };
39731     } catch (Dali::DaliException e) {
39732       {
39733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39734       };
39735     } catch (...) {
39736       {
39737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39738       };
39739     }
39740   }
39741
39742 }
39743
39744
39745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39746   void * jresult ;
39747   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39748   Dali::CustomActorImpl *result = 0 ;
39749
39750   arg1 = (Dali::CustomActor *)jarg1;
39751   {
39752     try {
39753       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39754     } catch (std::out_of_range& e) {
39755       {
39756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39757       };
39758     } catch (std::exception& e) {
39759       {
39760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39761       };
39762     } catch (Dali::DaliException e) {
39763       {
39764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39765       };
39766     } catch (...) {
39767       {
39768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39769       };
39770     }
39771   }
39772
39773   jresult = (void *)result;
39774   return jresult;
39775 }
39776
39777
39778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39779   void * jresult ;
39780   Dali::CustomActorImpl *arg1 = 0 ;
39781   Dali::CustomActor *result = 0 ;
39782
39783   arg1 = (Dali::CustomActorImpl *)jarg1;
39784   if (!arg1) {
39785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39786     return 0;
39787   }
39788   {
39789     try {
39790       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39791     } catch (std::out_of_range& e) {
39792       {
39793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39794       };
39795     } catch (std::exception& e) {
39796       {
39797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39798       };
39799     } catch (Dali::DaliException e) {
39800       {
39801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39802       };
39803     } catch (...) {
39804       {
39805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39806       };
39807     }
39808   }
39809
39810   jresult = (void *)result;
39811   return jresult;
39812 }
39813
39814
39815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39816   void * jresult ;
39817   Dali::CustomActor *arg1 = 0 ;
39818   Dali::CustomActor *result = 0 ;
39819
39820   arg1 = (Dali::CustomActor *)jarg1;
39821   if (!arg1) {
39822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39823     return 0;
39824   }
39825   {
39826     try {
39827       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
39828     } catch (std::out_of_range& e) {
39829       {
39830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39831       };
39832     } catch (std::exception& e) {
39833       {
39834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39835       };
39836     } catch (Dali::DaliException e) {
39837       {
39838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39839       };
39840     } catch (...) {
39841       {
39842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39843       };
39844     }
39845   }
39846
39847   jresult = (void *)result;
39848   return jresult;
39849 }
39850
39851
39852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
39853   void * jresult ;
39854   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39855   Dali::CustomActor *arg2 = 0 ;
39856   Dali::CustomActor *result = 0 ;
39857
39858   arg1 = (Dali::CustomActor *)jarg1;
39859   arg2 = (Dali::CustomActor *)jarg2;
39860   if (!arg2) {
39861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39862     return 0;
39863   }
39864   {
39865     try {
39866       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
39867     } catch (std::out_of_range& e) {
39868       {
39869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39870       };
39871     } catch (std::exception& e) {
39872       {
39873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39874       };
39875     } catch (Dali::DaliException e) {
39876       {
39877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39878       };
39879     } catch (...) {
39880       {
39881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39882       };
39883     }
39884   }
39885
39886   jresult = (void *)result;
39887   return jresult;
39888 }
39889
39890
39891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
39892   int jresult ;
39893   int result;
39894
39895   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
39896   jresult = (int)result;
39897   return jresult;
39898 }
39899
39900
39901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
39902   int jresult ;
39903   int result;
39904
39905   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
39906   jresult = (int)result;
39907   return jresult;
39908 }
39909
39910
39911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
39912   int jresult ;
39913   int result;
39914
39915   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
39916   jresult = (int)result;
39917   return jresult;
39918 }
39919
39920
39921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
39922   int jresult ;
39923   int result;
39924
39925   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
39926   jresult = (int)result;
39927   return jresult;
39928 }
39929
39930
39931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
39932   int jresult ;
39933   int result;
39934
39935   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
39936   jresult = (int)result;
39937   return jresult;
39938 }
39939
39940
39941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
39942   int jresult ;
39943   int result;
39944
39945   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
39946   jresult = (int)result;
39947   return jresult;
39948 }
39949
39950
39951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
39952   int jresult ;
39953   int result;
39954
39955   result = (int)Dali::PanGestureDetector::Property::PANNING;
39956   jresult = (int)result;
39957   return jresult;
39958 }
39959
39960
39961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
39962   void * jresult ;
39963   Dali::PanGestureDetector::Property *result = 0 ;
39964
39965   {
39966     try {
39967       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
39968     } catch (std::out_of_range& e) {
39969       {
39970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39971       };
39972     } catch (std::exception& e) {
39973       {
39974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39975       };
39976     } catch (Dali::DaliException e) {
39977       {
39978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39979       };
39980     } catch (...) {
39981       {
39982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39983       };
39984     }
39985   }
39986
39987   jresult = (void *)result;
39988   return jresult;
39989 }
39990
39991
39992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
39993   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
39994
39995   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
39996   {
39997     try {
39998       delete arg1;
39999     } catch (std::out_of_range& e) {
40000       {
40001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40002       };
40003     } catch (std::exception& e) {
40004       {
40005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40006       };
40007     } catch (Dali::DaliException e) {
40008       {
40009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40010       };
40011     } catch (...) {
40012       {
40013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40014       };
40015     }
40016   }
40017
40018 }
40019
40020
40021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40022   void * jresult ;
40023   Dali::Radian *result = 0 ;
40024
40025   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40026   jresult = (void *)result;
40027   return jresult;
40028 }
40029
40030
40031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40032   void * jresult ;
40033   Dali::Radian *result = 0 ;
40034
40035   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40036   jresult = (void *)result;
40037   return jresult;
40038 }
40039
40040
40041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40042   void * jresult ;
40043   Dali::Radian *result = 0 ;
40044
40045   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40046   jresult = (void *)result;
40047   return jresult;
40048 }
40049
40050
40051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40052   void * jresult ;
40053   Dali::Radian *result = 0 ;
40054
40055   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40056   jresult = (void *)result;
40057   return jresult;
40058 }
40059
40060
40061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40062   void * jresult ;
40063   Dali::Radian *result = 0 ;
40064
40065   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40066   jresult = (void *)result;
40067   return jresult;
40068 }
40069
40070
40071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40072   void * jresult ;
40073   Dali::Radian *result = 0 ;
40074
40075   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40076   jresult = (void *)result;
40077   return jresult;
40078 }
40079
40080
40081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40082   void * jresult ;
40083   Dali::Radian *result = 0 ;
40084
40085   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40086   jresult = (void *)result;
40087   return jresult;
40088 }
40089
40090
40091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40092   void * jresult ;
40093   Dali::PanGestureDetector *result = 0 ;
40094
40095   {
40096     try {
40097       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40098     } catch (std::out_of_range& e) {
40099       {
40100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40101       };
40102     } catch (std::exception& e) {
40103       {
40104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40105       };
40106     } catch (Dali::DaliException e) {
40107       {
40108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40109       };
40110     } catch (...) {
40111       {
40112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40113       };
40114     }
40115   }
40116
40117   jresult = (void *)result;
40118   return jresult;
40119 }
40120
40121
40122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40123   void * jresult ;
40124   Dali::PanGestureDetector result;
40125
40126   {
40127     try {
40128       result = Dali::PanGestureDetector::New();
40129     } catch (std::out_of_range& e) {
40130       {
40131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40132       };
40133     } catch (std::exception& e) {
40134       {
40135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40136       };
40137     } catch (Dali::DaliException e) {
40138       {
40139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40140       };
40141     } catch (...) {
40142       {
40143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40144       };
40145     }
40146   }
40147
40148   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40149   return jresult;
40150 }
40151
40152
40153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40154   void * jresult ;
40155   Dali::BaseHandle arg1 ;
40156   Dali::BaseHandle *argp1 ;
40157   Dali::PanGestureDetector result;
40158
40159   argp1 = (Dali::BaseHandle *)jarg1;
40160   if (!argp1) {
40161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40162     return 0;
40163   }
40164   arg1 = *argp1;
40165   {
40166     try {
40167       result = Dali::PanGestureDetector::DownCast(arg1);
40168     } catch (std::out_of_range& e) {
40169       {
40170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40171       };
40172     } catch (std::exception& e) {
40173       {
40174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40175       };
40176     } catch (Dali::DaliException e) {
40177       {
40178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40179       };
40180     } catch (...) {
40181       {
40182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40183       };
40184     }
40185   }
40186
40187   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40188   return jresult;
40189 }
40190
40191
40192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40193   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40194
40195   arg1 = (Dali::PanGestureDetector *)jarg1;
40196   {
40197     try {
40198       delete arg1;
40199     } catch (std::out_of_range& e) {
40200       {
40201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40202       };
40203     } catch (std::exception& e) {
40204       {
40205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40206       };
40207     } catch (Dali::DaliException e) {
40208       {
40209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40210       };
40211     } catch (...) {
40212       {
40213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40214       };
40215     }
40216   }
40217
40218 }
40219
40220
40221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40222   void * jresult ;
40223   Dali::PanGestureDetector *arg1 = 0 ;
40224   Dali::PanGestureDetector *result = 0 ;
40225
40226   arg1 = (Dali::PanGestureDetector *)jarg1;
40227   if (!arg1) {
40228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40229     return 0;
40230   }
40231   {
40232     try {
40233       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40234     } catch (std::out_of_range& e) {
40235       {
40236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40237       };
40238     } catch (std::exception& e) {
40239       {
40240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40241       };
40242     } catch (Dali::DaliException e) {
40243       {
40244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40245       };
40246     } catch (...) {
40247       {
40248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40249       };
40250     }
40251   }
40252
40253   jresult = (void *)result;
40254   return jresult;
40255 }
40256
40257
40258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40259   void * jresult ;
40260   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40261   Dali::PanGestureDetector *arg2 = 0 ;
40262   Dali::PanGestureDetector *result = 0 ;
40263
40264   arg1 = (Dali::PanGestureDetector *)jarg1;
40265   arg2 = (Dali::PanGestureDetector *)jarg2;
40266   if (!arg2) {
40267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40268     return 0;
40269   }
40270   {
40271     try {
40272       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40273     } catch (std::out_of_range& e) {
40274       {
40275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40276       };
40277     } catch (std::exception& e) {
40278       {
40279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40280       };
40281     } catch (Dali::DaliException e) {
40282       {
40283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40284       };
40285     } catch (...) {
40286       {
40287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40288       };
40289     }
40290   }
40291
40292   jresult = (void *)result;
40293   return jresult;
40294 }
40295
40296
40297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40298   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40299   unsigned int arg2 ;
40300
40301   arg1 = (Dali::PanGestureDetector *)jarg1;
40302   arg2 = (unsigned int)jarg2;
40303   {
40304     try {
40305       (arg1)->SetMinimumTouchesRequired(arg2);
40306     } catch (std::out_of_range& e) {
40307       {
40308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40309       };
40310     } catch (std::exception& e) {
40311       {
40312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40313       };
40314     } catch (Dali::DaliException e) {
40315       {
40316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40317       };
40318     } catch (...) {
40319       {
40320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40321       };
40322     }
40323   }
40324
40325 }
40326
40327
40328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40329   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40330   unsigned int arg2 ;
40331
40332   arg1 = (Dali::PanGestureDetector *)jarg1;
40333   arg2 = (unsigned int)jarg2;
40334   {
40335     try {
40336       (arg1)->SetMaximumTouchesRequired(arg2);
40337     } catch (std::out_of_range& e) {
40338       {
40339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40340       };
40341     } catch (std::exception& e) {
40342       {
40343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40344       };
40345     } catch (Dali::DaliException e) {
40346       {
40347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40348       };
40349     } catch (...) {
40350       {
40351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40352       };
40353     }
40354   }
40355
40356 }
40357
40358
40359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40360   unsigned int jresult ;
40361   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40362   unsigned int result;
40363
40364   arg1 = (Dali::PanGestureDetector *)jarg1;
40365   {
40366     try {
40367       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40368     } catch (std::out_of_range& e) {
40369       {
40370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40371       };
40372     } catch (std::exception& e) {
40373       {
40374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40375       };
40376     } catch (Dali::DaliException e) {
40377       {
40378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40379       };
40380     } catch (...) {
40381       {
40382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40383       };
40384     }
40385   }
40386
40387   jresult = result;
40388   return jresult;
40389 }
40390
40391
40392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40393   unsigned int jresult ;
40394   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40395   unsigned int result;
40396
40397   arg1 = (Dali::PanGestureDetector *)jarg1;
40398   {
40399     try {
40400       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40401     } catch (std::out_of_range& e) {
40402       {
40403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40404       };
40405     } catch (std::exception& e) {
40406       {
40407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40408       };
40409     } catch (Dali::DaliException e) {
40410       {
40411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40412       };
40413     } catch (...) {
40414       {
40415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40416       };
40417     }
40418   }
40419
40420   jresult = result;
40421   return jresult;
40422 }
40423
40424
40425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40426   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40427   Dali::Radian arg2 ;
40428   Dali::Radian arg3 ;
40429   Dali::Radian *argp2 ;
40430   Dali::Radian *argp3 ;
40431
40432   arg1 = (Dali::PanGestureDetector *)jarg1;
40433   argp2 = (Dali::Radian *)jarg2;
40434   if (!argp2) {
40435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40436     return ;
40437   }
40438   arg2 = *argp2;
40439   argp3 = (Dali::Radian *)jarg3;
40440   if (!argp3) {
40441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40442     return ;
40443   }
40444   arg3 = *argp3;
40445   {
40446     try {
40447       (arg1)->AddAngle(arg2,arg3);
40448     } catch (std::out_of_range& e) {
40449       {
40450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40451       };
40452     } catch (std::exception& e) {
40453       {
40454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40455       };
40456     } catch (Dali::DaliException e) {
40457       {
40458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40459       };
40460     } catch (...) {
40461       {
40462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40463       };
40464     }
40465   }
40466
40467 }
40468
40469
40470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40471   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40472   Dali::Radian arg2 ;
40473   Dali::Radian *argp2 ;
40474
40475   arg1 = (Dali::PanGestureDetector *)jarg1;
40476   argp2 = (Dali::Radian *)jarg2;
40477   if (!argp2) {
40478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40479     return ;
40480   }
40481   arg2 = *argp2;
40482   {
40483     try {
40484       (arg1)->AddAngle(arg2);
40485     } catch (std::out_of_range& e) {
40486       {
40487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40488       };
40489     } catch (std::exception& e) {
40490       {
40491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40492       };
40493     } catch (Dali::DaliException e) {
40494       {
40495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40496       };
40497     } catch (...) {
40498       {
40499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40500       };
40501     }
40502   }
40503
40504 }
40505
40506
40507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40508   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40509   Dali::Radian arg2 ;
40510   Dali::Radian arg3 ;
40511   Dali::Radian *argp2 ;
40512   Dali::Radian *argp3 ;
40513
40514   arg1 = (Dali::PanGestureDetector *)jarg1;
40515   argp2 = (Dali::Radian *)jarg2;
40516   if (!argp2) {
40517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40518     return ;
40519   }
40520   arg2 = *argp2;
40521   argp3 = (Dali::Radian *)jarg3;
40522   if (!argp3) {
40523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40524     return ;
40525   }
40526   arg3 = *argp3;
40527   {
40528     try {
40529       (arg1)->AddDirection(arg2,arg3);
40530     } catch (std::out_of_range& e) {
40531       {
40532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40533       };
40534     } catch (std::exception& e) {
40535       {
40536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40537       };
40538     } catch (Dali::DaliException e) {
40539       {
40540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40541       };
40542     } catch (...) {
40543       {
40544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40545       };
40546     }
40547   }
40548
40549 }
40550
40551
40552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40553   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40554   Dali::Radian arg2 ;
40555   Dali::Radian *argp2 ;
40556
40557   arg1 = (Dali::PanGestureDetector *)jarg1;
40558   argp2 = (Dali::Radian *)jarg2;
40559   if (!argp2) {
40560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40561     return ;
40562   }
40563   arg2 = *argp2;
40564   {
40565     try {
40566       (arg1)->AddDirection(arg2);
40567     } catch (std::out_of_range& e) {
40568       {
40569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40570       };
40571     } catch (std::exception& e) {
40572       {
40573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40574       };
40575     } catch (Dali::DaliException e) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40578       };
40579     } catch (...) {
40580       {
40581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40582       };
40583     }
40584   }
40585
40586 }
40587
40588
40589 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40590   unsigned long jresult ;
40591   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40592   size_t result;
40593
40594   arg1 = (Dali::PanGestureDetector *)jarg1;
40595   {
40596     try {
40597       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40598     } catch (std::out_of_range& e) {
40599       {
40600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40601       };
40602     } catch (std::exception& e) {
40603       {
40604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40605       };
40606     } catch (Dali::DaliException e) {
40607       {
40608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40609       };
40610     } catch (...) {
40611       {
40612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40613       };
40614     }
40615   }
40616
40617   jresult = (unsigned long)result;
40618   return jresult;
40619 }
40620
40621
40622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40623   void * jresult ;
40624   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40625   size_t arg2 ;
40626   Dali::PanGestureDetector::AngleThresholdPair result;
40627
40628   arg1 = (Dali::PanGestureDetector *)jarg1;
40629   arg2 = (size_t)jarg2;
40630   {
40631     try {
40632       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40633     } catch (std::out_of_range& e) {
40634       {
40635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40636       };
40637     } catch (std::exception& e) {
40638       {
40639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40640       };
40641     } catch (Dali::DaliException e) {
40642       {
40643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40644       };
40645     } catch (...) {
40646       {
40647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40648       };
40649     }
40650   }
40651
40652   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40653   return jresult;
40654 }
40655
40656
40657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40658   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40659
40660   arg1 = (Dali::PanGestureDetector *)jarg1;
40661   {
40662     try {
40663       (arg1)->ClearAngles();
40664     } catch (std::out_of_range& e) {
40665       {
40666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40667       };
40668     } catch (std::exception& e) {
40669       {
40670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40671       };
40672     } catch (Dali::DaliException e) {
40673       {
40674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40675       };
40676     } catch (...) {
40677       {
40678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40679       };
40680     }
40681   }
40682
40683 }
40684
40685
40686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40687   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40688   Dali::Radian arg2 ;
40689   Dali::Radian *argp2 ;
40690
40691   arg1 = (Dali::PanGestureDetector *)jarg1;
40692   argp2 = (Dali::Radian *)jarg2;
40693   if (!argp2) {
40694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40695     return ;
40696   }
40697   arg2 = *argp2;
40698   {
40699     try {
40700       (arg1)->RemoveAngle(arg2);
40701     } catch (std::out_of_range& e) {
40702       {
40703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40704       };
40705     } catch (std::exception& e) {
40706       {
40707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40708       };
40709     } catch (Dali::DaliException e) {
40710       {
40711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40712       };
40713     } catch (...) {
40714       {
40715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40716       };
40717     }
40718   }
40719
40720 }
40721
40722
40723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40724   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40725   Dali::Radian arg2 ;
40726   Dali::Radian *argp2 ;
40727
40728   arg1 = (Dali::PanGestureDetector *)jarg1;
40729   argp2 = (Dali::Radian *)jarg2;
40730   if (!argp2) {
40731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40732     return ;
40733   }
40734   arg2 = *argp2;
40735   {
40736     try {
40737       (arg1)->RemoveDirection(arg2);
40738     } catch (std::out_of_range& e) {
40739       {
40740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40741       };
40742     } catch (std::exception& e) {
40743       {
40744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40745       };
40746     } catch (Dali::DaliException e) {
40747       {
40748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40749       };
40750     } catch (...) {
40751       {
40752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40753       };
40754     }
40755   }
40756
40757 }
40758
40759
40760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40761   void * jresult ;
40762   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40763   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40764
40765   arg1 = (Dali::PanGestureDetector *)jarg1;
40766   {
40767     try {
40768       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40769     } catch (std::out_of_range& e) {
40770       {
40771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40772       };
40773     } catch (std::exception& e) {
40774       {
40775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40776       };
40777     } catch (Dali::DaliException e) {
40778       {
40779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40780       };
40781     } catch (...) {
40782       {
40783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40784       };
40785     }
40786   }
40787
40788   jresult = (void *)result;
40789   return jresult;
40790 }
40791
40792
40793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40794   Dali::PanGesture *arg1 = 0 ;
40795
40796   arg1 = (Dali::PanGesture *)jarg1;
40797   if (!arg1) {
40798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40799     return ;
40800   }
40801   {
40802     try {
40803       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40804     } catch (std::out_of_range& e) {
40805       {
40806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40807       };
40808     } catch (std::exception& e) {
40809       {
40810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40811       };
40812     } catch (Dali::DaliException e) {
40813       {
40814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40815       };
40816     } catch (...) {
40817       {
40818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40819       };
40820     }
40821   }
40822
40823 }
40824
40825
40826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
40827   void * jresult ;
40828   Dali::PanGesture *result = 0 ;
40829
40830   {
40831     try {
40832       result = (Dali::PanGesture *)new Dali::PanGesture();
40833     } catch (std::out_of_range& e) {
40834       {
40835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40836       };
40837     } catch (std::exception& e) {
40838       {
40839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40840       };
40841     } catch (Dali::DaliException e) {
40842       {
40843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40844       };
40845     } catch (...) {
40846       {
40847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40848       };
40849     }
40850   }
40851
40852   jresult = (void *)result;
40853   return jresult;
40854 }
40855
40856
40857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
40858   void * jresult ;
40859   Dali::Gesture::State arg1 ;
40860   Dali::PanGesture *result = 0 ;
40861
40862   arg1 = (Dali::Gesture::State)jarg1;
40863   {
40864     try {
40865       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
40866     } catch (std::out_of_range& e) {
40867       {
40868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40869       };
40870     } catch (std::exception& e) {
40871       {
40872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40873       };
40874     } catch (Dali::DaliException e) {
40875       {
40876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40877       };
40878     } catch (...) {
40879       {
40880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40881       };
40882     }
40883   }
40884
40885   jresult = (void *)result;
40886   return jresult;
40887 }
40888
40889
40890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
40891   void * jresult ;
40892   Dali::PanGesture *arg1 = 0 ;
40893   Dali::PanGesture *result = 0 ;
40894
40895   arg1 = (Dali::PanGesture *)jarg1;
40896   if (!arg1) {
40897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40898     return 0;
40899   }
40900   {
40901     try {
40902       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
40903     } catch (std::out_of_range& e) {
40904       {
40905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40906       };
40907     } catch (std::exception& e) {
40908       {
40909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40910       };
40911     } catch (Dali::DaliException e) {
40912       {
40913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40914       };
40915     } catch (...) {
40916       {
40917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40918       };
40919     }
40920   }
40921
40922   jresult = (void *)result;
40923   return jresult;
40924 }
40925
40926
40927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
40928   void * jresult ;
40929   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40930   Dali::PanGesture *arg2 = 0 ;
40931   Dali::PanGesture *result = 0 ;
40932
40933   arg1 = (Dali::PanGesture *)jarg1;
40934   arg2 = (Dali::PanGesture *)jarg2;
40935   if (!arg2) {
40936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40937     return 0;
40938   }
40939   {
40940     try {
40941       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
40942     } catch (std::out_of_range& e) {
40943       {
40944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40945       };
40946     } catch (std::exception& e) {
40947       {
40948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40949       };
40950     } catch (Dali::DaliException e) {
40951       {
40952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40953       };
40954     } catch (...) {
40955       {
40956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40957       };
40958     }
40959   }
40960
40961   jresult = (void *)result;
40962   return jresult;
40963 }
40964
40965
40966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
40967   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40968
40969   arg1 = (Dali::PanGesture *)jarg1;
40970   {
40971     try {
40972       delete arg1;
40973     } catch (std::out_of_range& e) {
40974       {
40975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40976       };
40977     } catch (std::exception& e) {
40978       {
40979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40980       };
40981     } catch (Dali::DaliException e) {
40982       {
40983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40984       };
40985     } catch (...) {
40986       {
40987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40988       };
40989     }
40990   }
40991
40992 }
40993
40994
40995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
40996   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40997   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40998
40999   arg1 = (Dali::PanGesture *)jarg1;
41000   arg2 = (Dali::Vector2 *)jarg2;
41001   if (arg1) (arg1)->velocity = *arg2;
41002 }
41003
41004
41005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41006   void * jresult ;
41007   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41008   Dali::Vector2 *result = 0 ;
41009
41010   arg1 = (Dali::PanGesture *)jarg1;
41011   result = (Dali::Vector2 *)& ((arg1)->velocity);
41012   jresult = (void *)result;
41013   return jresult;
41014 }
41015
41016
41017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41018   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41019   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41020
41021   arg1 = (Dali::PanGesture *)jarg1;
41022   arg2 = (Dali::Vector2 *)jarg2;
41023   if (arg1) (arg1)->displacement = *arg2;
41024 }
41025
41026
41027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41028   void * jresult ;
41029   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41030   Dali::Vector2 *result = 0 ;
41031
41032   arg1 = (Dali::PanGesture *)jarg1;
41033   result = (Dali::Vector2 *)& ((arg1)->displacement);
41034   jresult = (void *)result;
41035   return jresult;
41036 }
41037
41038
41039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41040   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41041   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41042
41043   arg1 = (Dali::PanGesture *)jarg1;
41044   arg2 = (Dali::Vector2 *)jarg2;
41045   if (arg1) (arg1)->position = *arg2;
41046 }
41047
41048
41049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41050   void * jresult ;
41051   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41052   Dali::Vector2 *result = 0 ;
41053
41054   arg1 = (Dali::PanGesture *)jarg1;
41055   result = (Dali::Vector2 *)& ((arg1)->position);
41056   jresult = (void *)result;
41057   return jresult;
41058 }
41059
41060
41061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41062   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41063   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41064
41065   arg1 = (Dali::PanGesture *)jarg1;
41066   arg2 = (Dali::Vector2 *)jarg2;
41067   if (arg1) (arg1)->screenVelocity = *arg2;
41068 }
41069
41070
41071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41072   void * jresult ;
41073   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41074   Dali::Vector2 *result = 0 ;
41075
41076   arg1 = (Dali::PanGesture *)jarg1;
41077   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41078   jresult = (void *)result;
41079   return jresult;
41080 }
41081
41082
41083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41084   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41085   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41086
41087   arg1 = (Dali::PanGesture *)jarg1;
41088   arg2 = (Dali::Vector2 *)jarg2;
41089   if (arg1) (arg1)->screenDisplacement = *arg2;
41090 }
41091
41092
41093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41094   void * jresult ;
41095   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41096   Dali::Vector2 *result = 0 ;
41097
41098   arg1 = (Dali::PanGesture *)jarg1;
41099   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41100   jresult = (void *)result;
41101   return jresult;
41102 }
41103
41104
41105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41106   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41107   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41108
41109   arg1 = (Dali::PanGesture *)jarg1;
41110   arg2 = (Dali::Vector2 *)jarg2;
41111   if (arg1) (arg1)->screenPosition = *arg2;
41112 }
41113
41114
41115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41116   void * jresult ;
41117   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41118   Dali::Vector2 *result = 0 ;
41119
41120   arg1 = (Dali::PanGesture *)jarg1;
41121   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41122   jresult = (void *)result;
41123   return jresult;
41124 }
41125
41126
41127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41128   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41129   unsigned int arg2 ;
41130
41131   arg1 = (Dali::PanGesture *)jarg1;
41132   arg2 = (unsigned int)jarg2;
41133   if (arg1) (arg1)->numberOfTouches = arg2;
41134 }
41135
41136
41137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41138   unsigned int jresult ;
41139   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41140   unsigned int result;
41141
41142   arg1 = (Dali::PanGesture *)jarg1;
41143   result = (unsigned int) ((arg1)->numberOfTouches);
41144   jresult = result;
41145   return jresult;
41146 }
41147
41148
41149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41150   float jresult ;
41151   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41152   float result;
41153
41154   arg1 = (Dali::PanGesture *)jarg1;
41155   {
41156     try {
41157       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41158     } catch (std::out_of_range& e) {
41159       {
41160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41161       };
41162     } catch (std::exception& e) {
41163       {
41164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41165       };
41166     } catch (Dali::DaliException e) {
41167       {
41168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41169       };
41170     } catch (...) {
41171       {
41172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41173       };
41174     }
41175   }
41176
41177   jresult = result;
41178   return jresult;
41179 }
41180
41181
41182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41183   float jresult ;
41184   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41185   float result;
41186
41187   arg1 = (Dali::PanGesture *)jarg1;
41188   {
41189     try {
41190       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41191     } catch (std::out_of_range& e) {
41192       {
41193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41194       };
41195     } catch (std::exception& e) {
41196       {
41197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41198       };
41199     } catch (Dali::DaliException e) {
41200       {
41201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41202       };
41203     } catch (...) {
41204       {
41205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41206       };
41207     }
41208   }
41209
41210   jresult = result;
41211   return jresult;
41212 }
41213
41214
41215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41216   float jresult ;
41217   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41218   float result;
41219
41220   arg1 = (Dali::PanGesture *)jarg1;
41221   {
41222     try {
41223       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41224     } catch (std::out_of_range& e) {
41225       {
41226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41227       };
41228     } catch (std::exception& e) {
41229       {
41230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41231       };
41232     } catch (Dali::DaliException e) {
41233       {
41234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41235       };
41236     } catch (...) {
41237       {
41238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41239       };
41240     }
41241   }
41242
41243   jresult = result;
41244   return jresult;
41245 }
41246
41247
41248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41249   float jresult ;
41250   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41251   float result;
41252
41253   arg1 = (Dali::PanGesture *)jarg1;
41254   {
41255     try {
41256       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41257     } catch (std::out_of_range& e) {
41258       {
41259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41260       };
41261     } catch (std::exception& e) {
41262       {
41263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41264       };
41265     } catch (Dali::DaliException e) {
41266       {
41267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41268       };
41269     } catch (...) {
41270       {
41271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41272       };
41273     }
41274   }
41275
41276   jresult = result;
41277   return jresult;
41278 }
41279
41280
41281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41282   void * jresult ;
41283   Dali::PinchGestureDetector *result = 0 ;
41284
41285   {
41286     try {
41287       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41288     } catch (std::out_of_range& e) {
41289       {
41290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41291       };
41292     } catch (std::exception& e) {
41293       {
41294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41295       };
41296     } catch (Dali::DaliException e) {
41297       {
41298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41299       };
41300     } catch (...) {
41301       {
41302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41303       };
41304     }
41305   }
41306
41307   jresult = (void *)result;
41308   return jresult;
41309 }
41310
41311
41312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41313   void * jresult ;
41314   Dali::PinchGestureDetector result;
41315
41316   {
41317     try {
41318       result = Dali::PinchGestureDetector::New();
41319     } catch (std::out_of_range& e) {
41320       {
41321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41322       };
41323     } catch (std::exception& e) {
41324       {
41325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41326       };
41327     } catch (Dali::DaliException e) {
41328       {
41329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41330       };
41331     } catch (...) {
41332       {
41333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41334       };
41335     }
41336   }
41337
41338   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41339   return jresult;
41340 }
41341
41342
41343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41344   void * jresult ;
41345   Dali::BaseHandle arg1 ;
41346   Dali::BaseHandle *argp1 ;
41347   Dali::PinchGestureDetector result;
41348
41349   argp1 = (Dali::BaseHandle *)jarg1;
41350   if (!argp1) {
41351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41352     return 0;
41353   }
41354   arg1 = *argp1;
41355   {
41356     try {
41357       result = Dali::PinchGestureDetector::DownCast(arg1);
41358     } catch (std::out_of_range& e) {
41359       {
41360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41361       };
41362     } catch (std::exception& e) {
41363       {
41364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41365       };
41366     } catch (Dali::DaliException e) {
41367       {
41368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41369       };
41370     } catch (...) {
41371       {
41372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41373       };
41374     }
41375   }
41376
41377   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41378   return jresult;
41379 }
41380
41381
41382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41383   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41384
41385   arg1 = (Dali::PinchGestureDetector *)jarg1;
41386   {
41387     try {
41388       delete arg1;
41389     } catch (std::out_of_range& e) {
41390       {
41391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41392       };
41393     } catch (std::exception& e) {
41394       {
41395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41396       };
41397     } catch (Dali::DaliException e) {
41398       {
41399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41400       };
41401     } catch (...) {
41402       {
41403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41404       };
41405     }
41406   }
41407
41408 }
41409
41410
41411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41412   void * jresult ;
41413   Dali::PinchGestureDetector *arg1 = 0 ;
41414   Dali::PinchGestureDetector *result = 0 ;
41415
41416   arg1 = (Dali::PinchGestureDetector *)jarg1;
41417   if (!arg1) {
41418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41419     return 0;
41420   }
41421   {
41422     try {
41423       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41424     } catch (std::out_of_range& e) {
41425       {
41426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41427       };
41428     } catch (std::exception& e) {
41429       {
41430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41431       };
41432     } catch (Dali::DaliException e) {
41433       {
41434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41435       };
41436     } catch (...) {
41437       {
41438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41439       };
41440     }
41441   }
41442
41443   jresult = (void *)result;
41444   return jresult;
41445 }
41446
41447
41448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41449   void * jresult ;
41450   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41451   Dali::PinchGestureDetector *arg2 = 0 ;
41452   Dali::PinchGestureDetector *result = 0 ;
41453
41454   arg1 = (Dali::PinchGestureDetector *)jarg1;
41455   arg2 = (Dali::PinchGestureDetector *)jarg2;
41456   if (!arg2) {
41457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41458     return 0;
41459   }
41460   {
41461     try {
41462       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41463     } catch (std::out_of_range& e) {
41464       {
41465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41466       };
41467     } catch (std::exception& e) {
41468       {
41469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41470       };
41471     } catch (Dali::DaliException e) {
41472       {
41473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41474       };
41475     } catch (...) {
41476       {
41477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41478       };
41479     }
41480   }
41481
41482   jresult = (void *)result;
41483   return jresult;
41484 }
41485
41486
41487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41488   void * jresult ;
41489   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41490   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41491
41492   arg1 = (Dali::PinchGestureDetector *)jarg1;
41493   {
41494     try {
41495       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41496     } catch (std::out_of_range& e) {
41497       {
41498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41499       };
41500     } catch (std::exception& e) {
41501       {
41502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41503       };
41504     } catch (Dali::DaliException e) {
41505       {
41506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41507       };
41508     } catch (...) {
41509       {
41510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41511       };
41512     }
41513   }
41514
41515   jresult = (void *)result;
41516   return jresult;
41517 }
41518
41519
41520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41521   void * jresult ;
41522   Dali::Gesture::State arg1 ;
41523   Dali::PinchGesture *result = 0 ;
41524
41525   arg1 = (Dali::Gesture::State)jarg1;
41526   {
41527     try {
41528       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41529     } catch (std::out_of_range& e) {
41530       {
41531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41532       };
41533     } catch (std::exception& e) {
41534       {
41535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41536       };
41537     } catch (Dali::DaliException e) {
41538       {
41539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41540       };
41541     } catch (...) {
41542       {
41543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41544       };
41545     }
41546   }
41547
41548   jresult = (void *)result;
41549   return jresult;
41550 }
41551
41552
41553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41554   void * jresult ;
41555   Dali::PinchGesture *arg1 = 0 ;
41556   Dali::PinchGesture *result = 0 ;
41557
41558   arg1 = (Dali::PinchGesture *)jarg1;
41559   if (!arg1) {
41560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41561     return 0;
41562   }
41563   {
41564     try {
41565       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41566     } catch (std::out_of_range& e) {
41567       {
41568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41569       };
41570     } catch (std::exception& e) {
41571       {
41572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41573       };
41574     } catch (Dali::DaliException e) {
41575       {
41576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41577       };
41578     } catch (...) {
41579       {
41580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41581       };
41582     }
41583   }
41584
41585   jresult = (void *)result;
41586   return jresult;
41587 }
41588
41589
41590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41591   void * jresult ;
41592   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41593   Dali::PinchGesture *arg2 = 0 ;
41594   Dali::PinchGesture *result = 0 ;
41595
41596   arg1 = (Dali::PinchGesture *)jarg1;
41597   arg2 = (Dali::PinchGesture *)jarg2;
41598   if (!arg2) {
41599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41600     return 0;
41601   }
41602   {
41603     try {
41604       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41605     } catch (std::out_of_range& e) {
41606       {
41607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41608       };
41609     } catch (std::exception& e) {
41610       {
41611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41612       };
41613     } catch (Dali::DaliException e) {
41614       {
41615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41616       };
41617     } catch (...) {
41618       {
41619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41620       };
41621     }
41622   }
41623
41624   jresult = (void *)result;
41625   return jresult;
41626 }
41627
41628
41629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41630   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41631
41632   arg1 = (Dali::PinchGesture *)jarg1;
41633   {
41634     try {
41635       delete arg1;
41636     } catch (std::out_of_range& e) {
41637       {
41638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41639       };
41640     } catch (std::exception& e) {
41641       {
41642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41643       };
41644     } catch (Dali::DaliException e) {
41645       {
41646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41647       };
41648     } catch (...) {
41649       {
41650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41651       };
41652     }
41653   }
41654
41655 }
41656
41657
41658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41659   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41660   float arg2 ;
41661
41662   arg1 = (Dali::PinchGesture *)jarg1;
41663   arg2 = (float)jarg2;
41664   if (arg1) (arg1)->scale = arg2;
41665 }
41666
41667
41668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41669   float jresult ;
41670   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41671   float result;
41672
41673   arg1 = (Dali::PinchGesture *)jarg1;
41674   result = (float) ((arg1)->scale);
41675   jresult = result;
41676   return jresult;
41677 }
41678
41679
41680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41681   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41682   float arg2 ;
41683
41684   arg1 = (Dali::PinchGesture *)jarg1;
41685   arg2 = (float)jarg2;
41686   if (arg1) (arg1)->speed = arg2;
41687 }
41688
41689
41690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41691   float jresult ;
41692   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41693   float result;
41694
41695   arg1 = (Dali::PinchGesture *)jarg1;
41696   result = (float) ((arg1)->speed);
41697   jresult = result;
41698   return jresult;
41699 }
41700
41701
41702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41703   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41704   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41705
41706   arg1 = (Dali::PinchGesture *)jarg1;
41707   arg2 = (Dali::Vector2 *)jarg2;
41708   if (arg1) (arg1)->screenCenterPoint = *arg2;
41709 }
41710
41711
41712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41713   void * jresult ;
41714   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41715   Dali::Vector2 *result = 0 ;
41716
41717   arg1 = (Dali::PinchGesture *)jarg1;
41718   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41719   jresult = (void *)result;
41720   return jresult;
41721 }
41722
41723
41724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41725   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41726   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41727
41728   arg1 = (Dali::PinchGesture *)jarg1;
41729   arg2 = (Dali::Vector2 *)jarg2;
41730   if (arg1) (arg1)->localCenterPoint = *arg2;
41731 }
41732
41733
41734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41735   void * jresult ;
41736   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41737   Dali::Vector2 *result = 0 ;
41738
41739   arg1 = (Dali::PinchGesture *)jarg1;
41740   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41741   jresult = (void *)result;
41742   return jresult;
41743 }
41744
41745
41746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41747   void * jresult ;
41748   Dali::TapGestureDetector *result = 0 ;
41749
41750   {
41751     try {
41752       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41753     } catch (std::out_of_range& e) {
41754       {
41755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (std::exception& e) {
41758       {
41759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (Dali::DaliException e) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41764       };
41765     } catch (...) {
41766       {
41767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41768       };
41769     }
41770   }
41771
41772   jresult = (void *)result;
41773   return jresult;
41774 }
41775
41776
41777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41778   void * jresult ;
41779   Dali::TapGestureDetector result;
41780
41781   {
41782     try {
41783       result = Dali::TapGestureDetector::New();
41784     } catch (std::out_of_range& e) {
41785       {
41786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41787       };
41788     } catch (std::exception& e) {
41789       {
41790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41791       };
41792     } catch (Dali::DaliException e) {
41793       {
41794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41795       };
41796     } catch (...) {
41797       {
41798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41799       };
41800     }
41801   }
41802
41803   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41804   return jresult;
41805 }
41806
41807
41808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41809   void * jresult ;
41810   unsigned int arg1 ;
41811   Dali::TapGestureDetector result;
41812
41813   arg1 = (unsigned int)jarg1;
41814   {
41815     try {
41816       result = Dali::TapGestureDetector::New(arg1);
41817     } catch (std::out_of_range& e) {
41818       {
41819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41820       };
41821     } catch (std::exception& e) {
41822       {
41823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41824       };
41825     } catch (Dali::DaliException e) {
41826       {
41827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41828       };
41829     } catch (...) {
41830       {
41831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41832       };
41833     }
41834   }
41835
41836   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41837   return jresult;
41838 }
41839
41840
41841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
41842   void * jresult ;
41843   Dali::BaseHandle arg1 ;
41844   Dali::BaseHandle *argp1 ;
41845   Dali::TapGestureDetector result;
41846
41847   argp1 = (Dali::BaseHandle *)jarg1;
41848   if (!argp1) {
41849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41850     return 0;
41851   }
41852   arg1 = *argp1;
41853   {
41854     try {
41855       result = Dali::TapGestureDetector::DownCast(arg1);
41856     } catch (std::out_of_range& e) {
41857       {
41858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41859       };
41860     } catch (std::exception& e) {
41861       {
41862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41863       };
41864     } catch (Dali::DaliException e) {
41865       {
41866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41867       };
41868     } catch (...) {
41869       {
41870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41871       };
41872     }
41873   }
41874
41875   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41876   return jresult;
41877 }
41878
41879
41880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
41881   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41882
41883   arg1 = (Dali::TapGestureDetector *)jarg1;
41884   {
41885     try {
41886       delete arg1;
41887     } catch (std::out_of_range& e) {
41888       {
41889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41890       };
41891     } catch (std::exception& e) {
41892       {
41893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41894       };
41895     } catch (Dali::DaliException e) {
41896       {
41897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41898       };
41899     } catch (...) {
41900       {
41901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41902       };
41903     }
41904   }
41905
41906 }
41907
41908
41909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
41910   void * jresult ;
41911   Dali::TapGestureDetector *arg1 = 0 ;
41912   Dali::TapGestureDetector *result = 0 ;
41913
41914   arg1 = (Dali::TapGestureDetector *)jarg1;
41915   if (!arg1) {
41916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41917     return 0;
41918   }
41919   {
41920     try {
41921       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
41922     } catch (std::out_of_range& e) {
41923       {
41924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41925       };
41926     } catch (std::exception& e) {
41927       {
41928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41929       };
41930     } catch (Dali::DaliException e) {
41931       {
41932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41933       };
41934     } catch (...) {
41935       {
41936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41937       };
41938     }
41939   }
41940
41941   jresult = (void *)result;
41942   return jresult;
41943 }
41944
41945
41946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
41947   void * jresult ;
41948   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41949   Dali::TapGestureDetector *arg2 = 0 ;
41950   Dali::TapGestureDetector *result = 0 ;
41951
41952   arg1 = (Dali::TapGestureDetector *)jarg1;
41953   arg2 = (Dali::TapGestureDetector *)jarg2;
41954   if (!arg2) {
41955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41956     return 0;
41957   }
41958   {
41959     try {
41960       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
41961     } catch (std::out_of_range& e) {
41962       {
41963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41964       };
41965     } catch (std::exception& e) {
41966       {
41967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41968       };
41969     } catch (Dali::DaliException e) {
41970       {
41971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41972       };
41973     } catch (...) {
41974       {
41975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41976       };
41977     }
41978   }
41979
41980   jresult = (void *)result;
41981   return jresult;
41982 }
41983
41984
41985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
41986   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41987   unsigned int arg2 ;
41988
41989   arg1 = (Dali::TapGestureDetector *)jarg1;
41990   arg2 = (unsigned int)jarg2;
41991   {
41992     try {
41993       (arg1)->SetMinimumTapsRequired(arg2);
41994     } catch (std::out_of_range& e) {
41995       {
41996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41997       };
41998     } catch (std::exception& e) {
41999       {
42000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42001       };
42002     } catch (Dali::DaliException e) {
42003       {
42004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42005       };
42006     } catch (...) {
42007       {
42008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42009       };
42010     }
42011   }
42012
42013 }
42014
42015
42016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42017   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42018   unsigned int arg2 ;
42019
42020   arg1 = (Dali::TapGestureDetector *)jarg1;
42021   arg2 = (unsigned int)jarg2;
42022   {
42023     try {
42024       (arg1)->SetMaximumTapsRequired(arg2);
42025     } catch (std::out_of_range& e) {
42026       {
42027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42028       };
42029     } catch (std::exception& e) {
42030       {
42031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42032       };
42033     } catch (Dali::DaliException e) {
42034       {
42035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42036       };
42037     } catch (...) {
42038       {
42039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42040       };
42041     }
42042   }
42043
42044 }
42045
42046
42047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42048   unsigned int jresult ;
42049   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42050   unsigned int result;
42051
42052   arg1 = (Dali::TapGestureDetector *)jarg1;
42053   {
42054     try {
42055       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42056     } catch (std::out_of_range& e) {
42057       {
42058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42059       };
42060     } catch (std::exception& e) {
42061       {
42062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42063       };
42064     } catch (Dali::DaliException e) {
42065       {
42066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42067       };
42068     } catch (...) {
42069       {
42070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42071       };
42072     }
42073   }
42074
42075   jresult = result;
42076   return jresult;
42077 }
42078
42079
42080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42081   unsigned int jresult ;
42082   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42083   unsigned int result;
42084
42085   arg1 = (Dali::TapGestureDetector *)jarg1;
42086   {
42087     try {
42088       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42089     } catch (std::out_of_range& e) {
42090       {
42091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42092       };
42093     } catch (std::exception& e) {
42094       {
42095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42096       };
42097     } catch (Dali::DaliException e) {
42098       {
42099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42100       };
42101     } catch (...) {
42102       {
42103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42104       };
42105     }
42106   }
42107
42108   jresult = result;
42109   return jresult;
42110 }
42111
42112
42113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42114   void * jresult ;
42115   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42116   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42117
42118   arg1 = (Dali::TapGestureDetector *)jarg1;
42119   {
42120     try {
42121       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42122     } catch (std::out_of_range& e) {
42123       {
42124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42125       };
42126     } catch (std::exception& e) {
42127       {
42128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42129       };
42130     } catch (Dali::DaliException e) {
42131       {
42132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42133       };
42134     } catch (...) {
42135       {
42136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42137       };
42138     }
42139   }
42140
42141   jresult = (void *)result;
42142   return jresult;
42143 }
42144
42145
42146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42147   void * jresult ;
42148   Dali::TapGesture *result = 0 ;
42149
42150   {
42151     try {
42152       result = (Dali::TapGesture *)new Dali::TapGesture();
42153     } catch (std::out_of_range& e) {
42154       {
42155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42156       };
42157     } catch (std::exception& e) {
42158       {
42159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42160       };
42161     } catch (Dali::DaliException e) {
42162       {
42163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42164       };
42165     } catch (...) {
42166       {
42167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42168       };
42169     }
42170   }
42171
42172   jresult = (void *)result;
42173   return jresult;
42174 }
42175
42176
42177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42178   void * jresult ;
42179   Dali::TapGesture *arg1 = 0 ;
42180   Dali::TapGesture *result = 0 ;
42181
42182   arg1 = (Dali::TapGesture *)jarg1;
42183   if (!arg1) {
42184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42185     return 0;
42186   }
42187   {
42188     try {
42189       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42190     } catch (std::out_of_range& e) {
42191       {
42192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42193       };
42194     } catch (std::exception& e) {
42195       {
42196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42197       };
42198     } catch (Dali::DaliException e) {
42199       {
42200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42201       };
42202     } catch (...) {
42203       {
42204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42205       };
42206     }
42207   }
42208
42209   jresult = (void *)result;
42210   return jresult;
42211 }
42212
42213
42214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42215   void * jresult ;
42216   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42217   Dali::TapGesture *arg2 = 0 ;
42218   Dali::TapGesture *result = 0 ;
42219
42220   arg1 = (Dali::TapGesture *)jarg1;
42221   arg2 = (Dali::TapGesture *)jarg2;
42222   if (!arg2) {
42223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42224     return 0;
42225   }
42226   {
42227     try {
42228       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42229     } catch (std::out_of_range& e) {
42230       {
42231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42232       };
42233     } catch (std::exception& e) {
42234       {
42235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42236       };
42237     } catch (Dali::DaliException e) {
42238       {
42239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42240       };
42241     } catch (...) {
42242       {
42243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42244       };
42245     }
42246   }
42247
42248   jresult = (void *)result;
42249   return jresult;
42250 }
42251
42252
42253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42254   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42255
42256   arg1 = (Dali::TapGesture *)jarg1;
42257   {
42258     try {
42259       delete arg1;
42260     } catch (std::out_of_range& e) {
42261       {
42262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42263       };
42264     } catch (std::exception& e) {
42265       {
42266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42267       };
42268     } catch (Dali::DaliException e) {
42269       {
42270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42271       };
42272     } catch (...) {
42273       {
42274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42275       };
42276     }
42277   }
42278
42279 }
42280
42281
42282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42283   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42284   unsigned int arg2 ;
42285
42286   arg1 = (Dali::TapGesture *)jarg1;
42287   arg2 = (unsigned int)jarg2;
42288   if (arg1) (arg1)->numberOfTaps = arg2;
42289 }
42290
42291
42292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42293   unsigned int jresult ;
42294   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42295   unsigned int result;
42296
42297   arg1 = (Dali::TapGesture *)jarg1;
42298   result = (unsigned int) ((arg1)->numberOfTaps);
42299   jresult = result;
42300   return jresult;
42301 }
42302
42303
42304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42305   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42306   unsigned int arg2 ;
42307
42308   arg1 = (Dali::TapGesture *)jarg1;
42309   arg2 = (unsigned int)jarg2;
42310   if (arg1) (arg1)->numberOfTouches = arg2;
42311 }
42312
42313
42314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42315   unsigned int jresult ;
42316   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42317   unsigned int result;
42318
42319   arg1 = (Dali::TapGesture *)jarg1;
42320   result = (unsigned int) ((arg1)->numberOfTouches);
42321   jresult = result;
42322   return jresult;
42323 }
42324
42325
42326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42327   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42328   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42329
42330   arg1 = (Dali::TapGesture *)jarg1;
42331   arg2 = (Dali::Vector2 *)jarg2;
42332   if (arg1) (arg1)->screenPoint = *arg2;
42333 }
42334
42335
42336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42337   void * jresult ;
42338   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42339   Dali::Vector2 *result = 0 ;
42340
42341   arg1 = (Dali::TapGesture *)jarg1;
42342   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42343   jresult = (void *)result;
42344   return jresult;
42345 }
42346
42347
42348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42349   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42350   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42351
42352   arg1 = (Dali::TapGesture *)jarg1;
42353   arg2 = (Dali::Vector2 *)jarg2;
42354   if (arg1) (arg1)->localPoint = *arg2;
42355 }
42356
42357
42358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42359   void * jresult ;
42360   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42361   Dali::Vector2 *result = 0 ;
42362
42363   arg1 = (Dali::TapGesture *)jarg1;
42364   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42365   jresult = (void *)result;
42366   return jresult;
42367 }
42368
42369
42370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42371   void * jresult ;
42372   Dali::AlphaFunction *result = 0 ;
42373
42374   {
42375     try {
42376       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42377     } catch (std::out_of_range& e) {
42378       {
42379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42380       };
42381     } catch (std::exception& e) {
42382       {
42383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42384       };
42385     } catch (Dali::DaliException e) {
42386       {
42387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42388       };
42389     } catch (...) {
42390       {
42391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42392       };
42393     }
42394   }
42395
42396   jresult = (void *)result;
42397   return jresult;
42398 }
42399
42400
42401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42402   void * jresult ;
42403   Dali::AlphaFunction::BuiltinFunction arg1 ;
42404   Dali::AlphaFunction *result = 0 ;
42405
42406   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42407   {
42408     try {
42409       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42410     } catch (std::out_of_range& e) {
42411       {
42412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42413       };
42414     } catch (std::exception& e) {
42415       {
42416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42417       };
42418     } catch (Dali::DaliException e) {
42419       {
42420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42421       };
42422     } catch (...) {
42423       {
42424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42425       };
42426     }
42427   }
42428
42429   jresult = (void *)result;
42430   return jresult;
42431 }
42432
42433
42434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42435   void * jresult ;
42436   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42437   Dali::AlphaFunction *result = 0 ;
42438
42439   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42440   {
42441     try {
42442       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42443     } catch (std::out_of_range& e) {
42444       {
42445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42446       };
42447     } catch (std::exception& e) {
42448       {
42449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42450       };
42451     } catch (Dali::DaliException e) {
42452       {
42453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42454       };
42455     } catch (...) {
42456       {
42457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42458       };
42459     }
42460   }
42461
42462   jresult = (void *)result;
42463   return jresult;
42464 }
42465
42466
42467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42468   void * jresult ;
42469   Dali::Vector2 *arg1 = 0 ;
42470   Dali::Vector2 *arg2 = 0 ;
42471   Dali::AlphaFunction *result = 0 ;
42472
42473   arg1 = (Dali::Vector2 *)jarg1;
42474   if (!arg1) {
42475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42476     return 0;
42477   }
42478   arg2 = (Dali::Vector2 *)jarg2;
42479   if (!arg2) {
42480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42481     return 0;
42482   }
42483   {
42484     try {
42485       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42486     } catch (std::out_of_range& e) {
42487       {
42488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42489       };
42490     } catch (std::exception& e) {
42491       {
42492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42493       };
42494     } catch (Dali::DaliException e) {
42495       {
42496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42497       };
42498     } catch (...) {
42499       {
42500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42501       };
42502     }
42503   }
42504
42505   jresult = (void *)result;
42506   return jresult;
42507 }
42508
42509
42510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42511   void * jresult ;
42512   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42513   Dali::Vector4 result;
42514
42515   arg1 = (Dali::AlphaFunction *)jarg1;
42516   {
42517     try {
42518       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42519     } catch (std::out_of_range& e) {
42520       {
42521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42522       };
42523     } catch (std::exception& e) {
42524       {
42525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42526       };
42527     } catch (Dali::DaliException e) {
42528       {
42529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42530       };
42531     } catch (...) {
42532       {
42533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42534       };
42535     }
42536   }
42537
42538   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42539   return jresult;
42540 }
42541
42542
42543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42544   void * jresult ;
42545   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42546   Dali::AlphaFunctionPrototype result;
42547
42548   arg1 = (Dali::AlphaFunction *)jarg1;
42549   {
42550     try {
42551       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42552     } catch (std::out_of_range& e) {
42553       {
42554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42555       };
42556     } catch (std::exception& e) {
42557       {
42558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42559       };
42560     } catch (Dali::DaliException e) {
42561       {
42562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42563       };
42564     } catch (...) {
42565       {
42566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42567       };
42568     }
42569   }
42570
42571   jresult = (void *)result;
42572   return jresult;
42573 }
42574
42575
42576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42577   int jresult ;
42578   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42579   Dali::AlphaFunction::BuiltinFunction result;
42580
42581   arg1 = (Dali::AlphaFunction *)jarg1;
42582   {
42583     try {
42584       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42585     } catch (std::out_of_range& e) {
42586       {
42587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42588       };
42589     } catch (std::exception& e) {
42590       {
42591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42592       };
42593     } catch (Dali::DaliException e) {
42594       {
42595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42596       };
42597     } catch (...) {
42598       {
42599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42600       };
42601     }
42602   }
42603
42604   jresult = (int)result;
42605   return jresult;
42606 }
42607
42608
42609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42610   int jresult ;
42611   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42612   Dali::AlphaFunction::Mode result;
42613
42614   arg1 = (Dali::AlphaFunction *)jarg1;
42615   {
42616     try {
42617       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42618     } catch (std::out_of_range& e) {
42619       {
42620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42621       };
42622     } catch (std::exception& e) {
42623       {
42624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42625       };
42626     } catch (Dali::DaliException e) {
42627       {
42628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42629       };
42630     } catch (...) {
42631       {
42632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42633       };
42634     }
42635   }
42636
42637   jresult = (int)result;
42638   return jresult;
42639 }
42640
42641
42642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42643   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42644
42645   arg1 = (Dali::AlphaFunction *)jarg1;
42646   {
42647     try {
42648       delete arg1;
42649     } catch (std::out_of_range& e) {
42650       {
42651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42652       };
42653     } catch (std::exception& e) {
42654       {
42655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42656       };
42657     } catch (Dali::DaliException e) {
42658       {
42659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42660       };
42661     } catch (...) {
42662       {
42663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42664       };
42665     }
42666   }
42667
42668 }
42669
42670
42671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42672   void * jresult ;
42673   Dali::KeyFrames result;
42674
42675   {
42676     try {
42677       result = Dali::KeyFrames::New();
42678     } catch (std::out_of_range& e) {
42679       {
42680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42681       };
42682     } catch (std::exception& e) {
42683       {
42684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42685       };
42686     } catch (Dali::DaliException e) {
42687       {
42688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42689       };
42690     } catch (...) {
42691       {
42692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42693       };
42694     }
42695   }
42696
42697   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42698   return jresult;
42699 }
42700
42701
42702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42703   void * jresult ;
42704   Dali::BaseHandle arg1 ;
42705   Dali::BaseHandle *argp1 ;
42706   Dali::KeyFrames result;
42707
42708   argp1 = (Dali::BaseHandle *)jarg1;
42709   if (!argp1) {
42710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42711     return 0;
42712   }
42713   arg1 = *argp1;
42714   {
42715     try {
42716       result = Dali::KeyFrames::DownCast(arg1);
42717     } catch (std::out_of_range& e) {
42718       {
42719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42720       };
42721     } catch (std::exception& e) {
42722       {
42723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42724       };
42725     } catch (Dali::DaliException e) {
42726       {
42727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42728       };
42729     } catch (...) {
42730       {
42731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42732       };
42733     }
42734   }
42735
42736   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42737   return jresult;
42738 }
42739
42740
42741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42742   void * jresult ;
42743   Dali::KeyFrames *result = 0 ;
42744
42745   {
42746     try {
42747       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42748     } catch (std::out_of_range& e) {
42749       {
42750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42751       };
42752     } catch (std::exception& e) {
42753       {
42754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42755       };
42756     } catch (Dali::DaliException e) {
42757       {
42758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42759       };
42760     } catch (...) {
42761       {
42762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42763       };
42764     }
42765   }
42766
42767   jresult = (void *)result;
42768   return jresult;
42769 }
42770
42771
42772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42773   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42774
42775   arg1 = (Dali::KeyFrames *)jarg1;
42776   {
42777     try {
42778       delete arg1;
42779     } catch (std::out_of_range& e) {
42780       {
42781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42782       };
42783     } catch (std::exception& e) {
42784       {
42785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42786       };
42787     } catch (Dali::DaliException e) {
42788       {
42789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42790       };
42791     } catch (...) {
42792       {
42793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42794       };
42795     }
42796   }
42797
42798 }
42799
42800
42801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42802   void * jresult ;
42803   Dali::KeyFrames *arg1 = 0 ;
42804   Dali::KeyFrames *result = 0 ;
42805
42806   arg1 = (Dali::KeyFrames *)jarg1;
42807   if (!arg1) {
42808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42809     return 0;
42810   }
42811   {
42812     try {
42813       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42814     } catch (std::out_of_range& e) {
42815       {
42816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42817       };
42818     } catch (std::exception& e) {
42819       {
42820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42821       };
42822     } catch (Dali::DaliException e) {
42823       {
42824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42825       };
42826     } catch (...) {
42827       {
42828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42829       };
42830     }
42831   }
42832
42833   jresult = (void *)result;
42834   return jresult;
42835 }
42836
42837
42838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
42839   void * jresult ;
42840   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42841   Dali::KeyFrames *arg2 = 0 ;
42842   Dali::KeyFrames *result = 0 ;
42843
42844   arg1 = (Dali::KeyFrames *)jarg1;
42845   arg2 = (Dali::KeyFrames *)jarg2;
42846   if (!arg2) {
42847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42848     return 0;
42849   }
42850   {
42851     try {
42852       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
42853     } catch (std::out_of_range& e) {
42854       {
42855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42856       };
42857     } catch (std::exception& e) {
42858       {
42859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42860       };
42861     } catch (Dali::DaliException e) {
42862       {
42863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42864       };
42865     } catch (...) {
42866       {
42867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42868       };
42869     }
42870   }
42871
42872   jresult = (void *)result;
42873   return jresult;
42874 }
42875
42876
42877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
42878   int jresult ;
42879   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42880   Dali::Property::Type result;
42881
42882   arg1 = (Dali::KeyFrames *)jarg1;
42883   {
42884     try {
42885       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
42886     } catch (std::out_of_range& e) {
42887       {
42888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42889       };
42890     } catch (std::exception& e) {
42891       {
42892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42893       };
42894     } catch (Dali::DaliException e) {
42895       {
42896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42897       };
42898     } catch (...) {
42899       {
42900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42901       };
42902     }
42903   }
42904
42905   jresult = (int)result;
42906   return jresult;
42907 }
42908
42909
42910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
42911   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42912   float arg2 ;
42913   Dali::Property::Value arg3 ;
42914   Dali::Property::Value *argp3 ;
42915
42916   arg1 = (Dali::KeyFrames *)jarg1;
42917   arg2 = (float)jarg2;
42918   argp3 = (Dali::Property::Value *)jarg3;
42919   if (!argp3) {
42920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42921     return ;
42922   }
42923   arg3 = *argp3;
42924   {
42925     try {
42926       (arg1)->Add(arg2,arg3);
42927     } catch (std::out_of_range& e) {
42928       {
42929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42930       };
42931     } catch (std::exception& e) {
42932       {
42933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42934       };
42935     } catch (Dali::DaliException e) {
42936       {
42937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42938       };
42939     } catch (...) {
42940       {
42941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42942       };
42943     }
42944   }
42945
42946 }
42947
42948
42949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
42950   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42951   float arg2 ;
42952   Dali::Property::Value arg3 ;
42953   Dali::AlphaFunction arg4 ;
42954   Dali::Property::Value *argp3 ;
42955   Dali::AlphaFunction *argp4 ;
42956
42957   arg1 = (Dali::KeyFrames *)jarg1;
42958   arg2 = (float)jarg2;
42959   argp3 = (Dali::Property::Value *)jarg3;
42960   if (!argp3) {
42961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42962     return ;
42963   }
42964   arg3 = *argp3;
42965   argp4 = (Dali::AlphaFunction *)jarg4;
42966   if (!argp4) {
42967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
42968     return ;
42969   }
42970   arg4 = *argp4;
42971   {
42972     try {
42973       (arg1)->Add(arg2,arg3,arg4);
42974     } catch (std::out_of_range& e) {
42975       {
42976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42977       };
42978     } catch (std::exception& e) {
42979       {
42980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42981       };
42982     } catch (Dali::DaliException e) {
42983       {
42984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42985       };
42986     } catch (...) {
42987       {
42988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42989       };
42990     }
42991   }
42992
42993 }
42994
42995
42996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
42997   int jresult ;
42998   int result;
42999
43000   result = (int)Dali::Path::Property::POINTS;
43001   jresult = (int)result;
43002   return jresult;
43003 }
43004
43005
43006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43007   int jresult ;
43008   int result;
43009
43010   result = (int)Dali::Path::Property::CONTROL_POINTS;
43011   jresult = (int)result;
43012   return jresult;
43013 }
43014
43015
43016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43017   void * jresult ;
43018   Dali::Path::Property *result = 0 ;
43019
43020   {
43021     try {
43022       result = (Dali::Path::Property *)new Dali::Path::Property();
43023     } catch (std::out_of_range& e) {
43024       {
43025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43026       };
43027     } catch (std::exception& e) {
43028       {
43029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43030       };
43031     } catch (Dali::DaliException e) {
43032       {
43033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43034       };
43035     } catch (...) {
43036       {
43037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43038       };
43039     }
43040   }
43041
43042   jresult = (void *)result;
43043   return jresult;
43044 }
43045
43046
43047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43048   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43049
43050   arg1 = (Dali::Path::Property *)jarg1;
43051   {
43052     try {
43053       delete arg1;
43054     } catch (std::out_of_range& e) {
43055       {
43056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43057       };
43058     } catch (std::exception& e) {
43059       {
43060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43061       };
43062     } catch (Dali::DaliException e) {
43063       {
43064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43065       };
43066     } catch (...) {
43067       {
43068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43069       };
43070     }
43071   }
43072
43073 }
43074
43075
43076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43077   void * jresult ;
43078   Dali::Path result;
43079
43080   {
43081     try {
43082       result = Dali::Path::New();
43083     } catch (std::out_of_range& e) {
43084       {
43085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43086       };
43087     } catch (std::exception& e) {
43088       {
43089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43090       };
43091     } catch (Dali::DaliException e) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43094       };
43095     } catch (...) {
43096       {
43097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43098       };
43099     }
43100   }
43101
43102   jresult = new Dali::Path((const Dali::Path &)result);
43103   return jresult;
43104 }
43105
43106
43107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43108   void * jresult ;
43109   Dali::BaseHandle arg1 ;
43110   Dali::BaseHandle *argp1 ;
43111   Dali::Path result;
43112
43113   argp1 = (Dali::BaseHandle *)jarg1;
43114   if (!argp1) {
43115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43116     return 0;
43117   }
43118   arg1 = *argp1;
43119   {
43120     try {
43121       result = Dali::Path::DownCast(arg1);
43122     } catch (std::out_of_range& e) {
43123       {
43124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43125       };
43126     } catch (std::exception& e) {
43127       {
43128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43129       };
43130     } catch (Dali::DaliException e) {
43131       {
43132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43133       };
43134     } catch (...) {
43135       {
43136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43137       };
43138     }
43139   }
43140
43141   jresult = new Dali::Path((const Dali::Path &)result);
43142   return jresult;
43143 }
43144
43145
43146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43147   void * jresult ;
43148   Dali::Path *result = 0 ;
43149
43150   {
43151     try {
43152       result = (Dali::Path *)new Dali::Path();
43153     } catch (std::out_of_range& e) {
43154       {
43155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43156       };
43157     } catch (std::exception& e) {
43158       {
43159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43160       };
43161     } catch (Dali::DaliException e) {
43162       {
43163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43164       };
43165     } catch (...) {
43166       {
43167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43168       };
43169     }
43170   }
43171
43172   jresult = (void *)result;
43173   return jresult;
43174 }
43175
43176
43177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43178   Dali::Path *arg1 = (Dali::Path *) 0 ;
43179
43180   arg1 = (Dali::Path *)jarg1;
43181   {
43182     try {
43183       delete arg1;
43184     } catch (std::out_of_range& e) {
43185       {
43186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43187       };
43188     } catch (std::exception& e) {
43189       {
43190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43191       };
43192     } catch (Dali::DaliException e) {
43193       {
43194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43195       };
43196     } catch (...) {
43197       {
43198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43199       };
43200     }
43201   }
43202
43203 }
43204
43205
43206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43207   void * jresult ;
43208   Dali::Path *arg1 = 0 ;
43209   Dali::Path *result = 0 ;
43210
43211   arg1 = (Dali::Path *)jarg1;
43212   if (!arg1) {
43213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43214     return 0;
43215   }
43216   {
43217     try {
43218       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43219     } catch (std::out_of_range& e) {
43220       {
43221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43222       };
43223     } catch (std::exception& e) {
43224       {
43225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43226       };
43227     } catch (Dali::DaliException e) {
43228       {
43229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43230       };
43231     } catch (...) {
43232       {
43233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43234       };
43235     }
43236   }
43237
43238   jresult = (void *)result;
43239   return jresult;
43240 }
43241
43242
43243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43244   void * jresult ;
43245   Dali::Path *arg1 = (Dali::Path *) 0 ;
43246   Dali::Path *arg2 = 0 ;
43247   Dali::Path *result = 0 ;
43248
43249   arg1 = (Dali::Path *)jarg1;
43250   arg2 = (Dali::Path *)jarg2;
43251   if (!arg2) {
43252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43253     return 0;
43254   }
43255   {
43256     try {
43257       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43258     } catch (std::out_of_range& e) {
43259       {
43260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43261       };
43262     } catch (std::exception& e) {
43263       {
43264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43265       };
43266     } catch (Dali::DaliException e) {
43267       {
43268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43269       };
43270     } catch (...) {
43271       {
43272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43273       };
43274     }
43275   }
43276
43277   jresult = (void *)result;
43278   return jresult;
43279 }
43280
43281
43282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43283   Dali::Path *arg1 = (Dali::Path *) 0 ;
43284   Dali::Vector3 *arg2 = 0 ;
43285
43286   arg1 = (Dali::Path *)jarg1;
43287   arg2 = (Dali::Vector3 *)jarg2;
43288   if (!arg2) {
43289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43290     return ;
43291   }
43292   {
43293     try {
43294       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43295     } catch (std::out_of_range& e) {
43296       {
43297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43298       };
43299     } catch (std::exception& e) {
43300       {
43301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43302       };
43303     } catch (Dali::DaliException e) {
43304       {
43305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43306       };
43307     } catch (...) {
43308       {
43309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43310       };
43311     }
43312   }
43313
43314 }
43315
43316
43317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43318   Dali::Path *arg1 = (Dali::Path *) 0 ;
43319   Dali::Vector3 *arg2 = 0 ;
43320
43321   arg1 = (Dali::Path *)jarg1;
43322   arg2 = (Dali::Vector3 *)jarg2;
43323   if (!arg2) {
43324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43325     return ;
43326   }
43327   {
43328     try {
43329       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43330     } catch (std::out_of_range& e) {
43331       {
43332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43333       };
43334     } catch (std::exception& e) {
43335       {
43336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43337       };
43338     } catch (Dali::DaliException e) {
43339       {
43340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43341       };
43342     } catch (...) {
43343       {
43344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43345       };
43346     }
43347   }
43348
43349 }
43350
43351
43352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43353   Dali::Path *arg1 = (Dali::Path *) 0 ;
43354   float arg2 ;
43355
43356   arg1 = (Dali::Path *)jarg1;
43357   arg2 = (float)jarg2;
43358   {
43359     try {
43360       (arg1)->GenerateControlPoints(arg2);
43361     } catch (std::out_of_range& e) {
43362       {
43363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43364       };
43365     } catch (std::exception& e) {
43366       {
43367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43368       };
43369     } catch (Dali::DaliException e) {
43370       {
43371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43372       };
43373     } catch (...) {
43374       {
43375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43376       };
43377     }
43378   }
43379
43380 }
43381
43382
43383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43384   Dali::Path *arg1 = (Dali::Path *) 0 ;
43385   float arg2 ;
43386   Dali::Vector3 *arg3 = 0 ;
43387   Dali::Vector3 *arg4 = 0 ;
43388
43389   arg1 = (Dali::Path *)jarg1;
43390   arg2 = (float)jarg2;
43391   arg3 = (Dali::Vector3 *)jarg3;
43392   if (!arg3) {
43393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43394     return ;
43395   }
43396   arg4 = (Dali::Vector3 *)jarg4;
43397   if (!arg4) {
43398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43399     return ;
43400   }
43401   {
43402     try {
43403       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43404     } catch (std::out_of_range& e) {
43405       {
43406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43407       };
43408     } catch (std::exception& e) {
43409       {
43410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43411       };
43412     } catch (Dali::DaliException e) {
43413       {
43414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43415       };
43416     } catch (...) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43419       };
43420     }
43421   }
43422
43423 }
43424
43425
43426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43427   void * jresult ;
43428   Dali::Path *arg1 = (Dali::Path *) 0 ;
43429   size_t arg2 ;
43430   Dali::Vector3 *result = 0 ;
43431
43432   arg1 = (Dali::Path *)jarg1;
43433   arg2 = (size_t)jarg2;
43434   {
43435     try {
43436       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43437     } catch (std::out_of_range& e) {
43438       {
43439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43440       };
43441     } catch (std::exception& e) {
43442       {
43443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43444       };
43445     } catch (Dali::DaliException e) {
43446       {
43447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43448       };
43449     } catch (...) {
43450       {
43451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43452       };
43453     }
43454   }
43455
43456   jresult = (void *)result;
43457   return jresult;
43458 }
43459
43460
43461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43462   void * jresult ;
43463   Dali::Path *arg1 = (Dali::Path *) 0 ;
43464   size_t arg2 ;
43465   Dali::Vector3 *result = 0 ;
43466
43467   arg1 = (Dali::Path *)jarg1;
43468   arg2 = (size_t)jarg2;
43469   {
43470     try {
43471       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43472     } catch (std::out_of_range& e) {
43473       {
43474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43475       };
43476     } catch (std::exception& e) {
43477       {
43478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43479       };
43480     } catch (Dali::DaliException e) {
43481       {
43482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43483       };
43484     } catch (...) {
43485       {
43486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43487       };
43488     }
43489   }
43490
43491   jresult = (void *)result;
43492   return jresult;
43493 }
43494
43495
43496 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43497   unsigned long jresult ;
43498   Dali::Path *arg1 = (Dali::Path *) 0 ;
43499   size_t result;
43500
43501   arg1 = (Dali::Path *)jarg1;
43502   {
43503     try {
43504       result = ((Dali::Path const *)arg1)->GetPointCount();
43505     } catch (std::out_of_range& e) {
43506       {
43507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43508       };
43509     } catch (std::exception& e) {
43510       {
43511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43512       };
43513     } catch (Dali::DaliException e) {
43514       {
43515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43516       };
43517     } catch (...) {
43518       {
43519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43520       };
43521     }
43522   }
43523
43524   jresult = (unsigned long)result;
43525   return jresult;
43526 }
43527
43528
43529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43530   void * jresult ;
43531   float arg1 ;
43532   Dali::TimePeriod *result = 0 ;
43533
43534   arg1 = (float)jarg1;
43535   {
43536     try {
43537       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43538     } catch (std::out_of_range& e) {
43539       {
43540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43541       };
43542     } catch (std::exception& e) {
43543       {
43544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43545       };
43546     } catch (Dali::DaliException e) {
43547       {
43548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43549       };
43550     } catch (...) {
43551       {
43552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43553       };
43554     }
43555   }
43556
43557   jresult = (void *)result;
43558   return jresult;
43559 }
43560
43561
43562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43563   void * jresult ;
43564   float arg1 ;
43565   float arg2 ;
43566   Dali::TimePeriod *result = 0 ;
43567
43568   arg1 = (float)jarg1;
43569   arg2 = (float)jarg2;
43570   {
43571     try {
43572       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43573     } catch (std::out_of_range& e) {
43574       {
43575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43576       };
43577     } catch (std::exception& e) {
43578       {
43579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43580       };
43581     } catch (Dali::DaliException e) {
43582       {
43583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43584       };
43585     } catch (...) {
43586       {
43587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43588       };
43589     }
43590   }
43591
43592   jresult = (void *)result;
43593   return jresult;
43594 }
43595
43596
43597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43598   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43599
43600   arg1 = (Dali::TimePeriod *)jarg1;
43601   {
43602     try {
43603       delete arg1;
43604     } catch (std::out_of_range& e) {
43605       {
43606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43607       };
43608     } catch (std::exception& e) {
43609       {
43610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43611       };
43612     } catch (Dali::DaliException e) {
43613       {
43614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43615       };
43616     } catch (...) {
43617       {
43618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43619       };
43620     }
43621   }
43622
43623 }
43624
43625
43626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43627   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43628   float arg2 ;
43629
43630   arg1 = (Dali::TimePeriod *)jarg1;
43631   arg2 = (float)jarg2;
43632   if (arg1) (arg1)->delaySeconds = arg2;
43633 }
43634
43635
43636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43637   float jresult ;
43638   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43639   float result;
43640
43641   arg1 = (Dali::TimePeriod *)jarg1;
43642   result = (float) ((arg1)->delaySeconds);
43643   jresult = result;
43644   return jresult;
43645 }
43646
43647
43648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43649   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43650   float arg2 ;
43651
43652   arg1 = (Dali::TimePeriod *)jarg1;
43653   arg2 = (float)jarg2;
43654   if (arg1) (arg1)->durationSeconds = arg2;
43655 }
43656
43657
43658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43659   float jresult ;
43660   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43661   float result;
43662
43663   arg1 = (Dali::TimePeriod *)jarg1;
43664   result = (float) ((arg1)->durationSeconds);
43665   jresult = result;
43666   return jresult;
43667 }
43668
43669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43670   int jresult ;
43671   int result;
43672
43673   result = (int)Dali::LinearConstrainer::Property::VALUE;
43674   jresult = (int)result;
43675   return jresult;
43676 }
43677
43678
43679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43680   int jresult ;
43681   int result;
43682
43683   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43684   jresult = (int)result;
43685   return jresult;
43686 }
43687
43688
43689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43690   void * jresult ;
43691   Dali::LinearConstrainer::Property *result = 0 ;
43692
43693   {
43694     try {
43695       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43696     } catch (std::out_of_range& e) {
43697       {
43698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43699       };
43700     } catch (std::exception& e) {
43701       {
43702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43703       };
43704     } catch (Dali::DaliException e) {
43705       {
43706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43707       };
43708     } catch (...) {
43709       {
43710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43711       };
43712     }
43713   }
43714
43715   jresult = (void *)result;
43716   return jresult;
43717 }
43718
43719
43720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43721   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43722
43723   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43724   {
43725     try {
43726       delete arg1;
43727     } catch (std::out_of_range& e) {
43728       {
43729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43730       };
43731     } catch (std::exception& e) {
43732       {
43733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43734       };
43735     } catch (Dali::DaliException e) {
43736       {
43737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43738       };
43739     } catch (...) {
43740       {
43741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43742       };
43743     }
43744   }
43745
43746 }
43747
43748
43749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43750   void * jresult ;
43751   Dali::LinearConstrainer result;
43752
43753   {
43754     try {
43755       result = Dali::LinearConstrainer::New();
43756     } catch (std::out_of_range& e) {
43757       {
43758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43759       };
43760     } catch (std::exception& e) {
43761       {
43762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43763       };
43764     } catch (Dali::DaliException e) {
43765       {
43766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43767       };
43768     } catch (...) {
43769       {
43770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43771       };
43772     }
43773   }
43774
43775   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43776   return jresult;
43777 }
43778
43779
43780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43781   void * jresult ;
43782   Dali::BaseHandle arg1 ;
43783   Dali::BaseHandle *argp1 ;
43784   Dali::LinearConstrainer result;
43785
43786   argp1 = (Dali::BaseHandle *)jarg1;
43787   if (!argp1) {
43788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43789     return 0;
43790   }
43791   arg1 = *argp1;
43792   {
43793     try {
43794       result = Dali::LinearConstrainer::DownCast(arg1);
43795     } catch (std::out_of_range& e) {
43796       {
43797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43798       };
43799     } catch (std::exception& e) {
43800       {
43801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43802       };
43803     } catch (Dali::DaliException e) {
43804       {
43805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43806       };
43807     } catch (...) {
43808       {
43809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43810       };
43811     }
43812   }
43813
43814   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43815   return jresult;
43816 }
43817
43818
43819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43820   void * jresult ;
43821   Dali::LinearConstrainer *result = 0 ;
43822
43823   {
43824     try {
43825       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
43826     } catch (std::out_of_range& e) {
43827       {
43828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43829       };
43830     } catch (std::exception& e) {
43831       {
43832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43833       };
43834     } catch (Dali::DaliException e) {
43835       {
43836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43837       };
43838     } catch (...) {
43839       {
43840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43841       };
43842     }
43843   }
43844
43845   jresult = (void *)result;
43846   return jresult;
43847 }
43848
43849
43850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
43851   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43852
43853   arg1 = (Dali::LinearConstrainer *)jarg1;
43854   {
43855     try {
43856       delete arg1;
43857     } catch (std::out_of_range& e) {
43858       {
43859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43860       };
43861     } catch (std::exception& e) {
43862       {
43863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43864       };
43865     } catch (Dali::DaliException e) {
43866       {
43867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43868       };
43869     } catch (...) {
43870       {
43871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43872       };
43873     }
43874   }
43875
43876 }
43877
43878
43879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
43880   void * jresult ;
43881   Dali::LinearConstrainer *arg1 = 0 ;
43882   Dali::LinearConstrainer *result = 0 ;
43883
43884   arg1 = (Dali::LinearConstrainer *)jarg1;
43885   if (!arg1) {
43886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43887     return 0;
43888   }
43889   {
43890     try {
43891       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
43892     } catch (std::out_of_range& e) {
43893       {
43894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43895       };
43896     } catch (std::exception& e) {
43897       {
43898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43899       };
43900     } catch (Dali::DaliException e) {
43901       {
43902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43903       };
43904     } catch (...) {
43905       {
43906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43907       };
43908     }
43909   }
43910
43911   jresult = (void *)result;
43912   return jresult;
43913 }
43914
43915
43916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
43917   void * jresult ;
43918   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43919   Dali::LinearConstrainer *arg2 = 0 ;
43920   Dali::LinearConstrainer *result = 0 ;
43921
43922   arg1 = (Dali::LinearConstrainer *)jarg1;
43923   arg2 = (Dali::LinearConstrainer *)jarg2;
43924   if (!arg2) {
43925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43926     return 0;
43927   }
43928   {
43929     try {
43930       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
43931     } catch (std::out_of_range& e) {
43932       {
43933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43934       };
43935     } catch (std::exception& e) {
43936       {
43937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43938       };
43939     } catch (Dali::DaliException e) {
43940       {
43941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43942       };
43943     } catch (...) {
43944       {
43945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43946       };
43947     }
43948   }
43949
43950   jresult = (void *)result;
43951   return jresult;
43952 }
43953
43954
43955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
43956   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43957   SwigValueWrapper< Dali::Property > arg2 ;
43958   SwigValueWrapper< Dali::Property > arg3 ;
43959   Dali::Vector2 *arg4 = 0 ;
43960   Dali::Vector2 *arg5 = 0 ;
43961   Dali::Property *argp2 ;
43962   Dali::Property *argp3 ;
43963
43964   arg1 = (Dali::LinearConstrainer *)jarg1;
43965   argp2 = (Dali::Property *)jarg2;
43966   if (!argp2) {
43967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43968     return ;
43969   }
43970   arg2 = *argp2;
43971   argp3 = (Dali::Property *)jarg3;
43972   if (!argp3) {
43973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43974     return ;
43975   }
43976   arg3 = *argp3;
43977   arg4 = (Dali::Vector2 *)jarg4;
43978   if (!arg4) {
43979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43980     return ;
43981   }
43982   arg5 = (Dali::Vector2 *)jarg5;
43983   if (!arg5) {
43984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43985     return ;
43986   }
43987   {
43988     try {
43989       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
43990     } catch (std::out_of_range& e) {
43991       {
43992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43993       };
43994     } catch (std::exception& e) {
43995       {
43996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43997       };
43998     } catch (Dali::DaliException e) {
43999       {
44000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44001       };
44002     } catch (...) {
44003       {
44004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44005       };
44006     }
44007   }
44008
44009 }
44010
44011
44012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44013   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44014   SwigValueWrapper< Dali::Property > arg2 ;
44015   SwigValueWrapper< Dali::Property > arg3 ;
44016   Dali::Vector2 *arg4 = 0 ;
44017   Dali::Property *argp2 ;
44018   Dali::Property *argp3 ;
44019
44020   arg1 = (Dali::LinearConstrainer *)jarg1;
44021   argp2 = (Dali::Property *)jarg2;
44022   if (!argp2) {
44023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44024     return ;
44025   }
44026   arg2 = *argp2;
44027   argp3 = (Dali::Property *)jarg3;
44028   if (!argp3) {
44029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44030     return ;
44031   }
44032   arg3 = *argp3;
44033   arg4 = (Dali::Vector2 *)jarg4;
44034   if (!arg4) {
44035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44036     return ;
44037   }
44038   {
44039     try {
44040       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44041     } catch (std::out_of_range& e) {
44042       {
44043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44044       };
44045     } catch (std::exception& e) {
44046       {
44047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44048       };
44049     } catch (Dali::DaliException e) {
44050       {
44051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44052       };
44053     } catch (...) {
44054       {
44055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44056       };
44057     }
44058   }
44059
44060 }
44061
44062
44063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44064   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44065   Dali::Handle *arg2 = 0 ;
44066
44067   arg1 = (Dali::LinearConstrainer *)jarg1;
44068   arg2 = (Dali::Handle *)jarg2;
44069   if (!arg2) {
44070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44071     return ;
44072   }
44073   {
44074     try {
44075       (arg1)->Remove(*arg2);
44076     } catch (std::out_of_range& e) {
44077       {
44078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44079       };
44080     } catch (std::exception& e) {
44081       {
44082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44083       };
44084     } catch (Dali::DaliException e) {
44085       {
44086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44087       };
44088     } catch (...) {
44089       {
44090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44091       };
44092     }
44093   }
44094
44095 }
44096
44097
44098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44099   int jresult ;
44100   int result;
44101
44102   result = (int)Dali::PathConstrainer::Property::FORWARD;
44103   jresult = (int)result;
44104   return jresult;
44105 }
44106
44107
44108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44109   int jresult ;
44110   int result;
44111
44112   result = (int)Dali::PathConstrainer::Property::POINTS;
44113   jresult = (int)result;
44114   return jresult;
44115 }
44116
44117
44118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44119   int jresult ;
44120   int result;
44121
44122   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44123   jresult = (int)result;
44124   return jresult;
44125 }
44126
44127
44128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44129   void * jresult ;
44130   Dali::PathConstrainer::Property *result = 0 ;
44131
44132   {
44133     try {
44134       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44135     } catch (std::out_of_range& e) {
44136       {
44137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44138       };
44139     } catch (std::exception& e) {
44140       {
44141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44142       };
44143     } catch (Dali::DaliException e) {
44144       {
44145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44146       };
44147     } catch (...) {
44148       {
44149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44150       };
44151     }
44152   }
44153
44154   jresult = (void *)result;
44155   return jresult;
44156 }
44157
44158
44159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44160   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44161
44162   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44163   {
44164     try {
44165       delete arg1;
44166     } catch (std::out_of_range& e) {
44167       {
44168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44169       };
44170     } catch (std::exception& e) {
44171       {
44172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44173       };
44174     } catch (Dali::DaliException e) {
44175       {
44176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44177       };
44178     } catch (...) {
44179       {
44180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44181       };
44182     }
44183   }
44184
44185 }
44186
44187
44188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44189   void * jresult ;
44190   Dali::PathConstrainer result;
44191
44192   {
44193     try {
44194       result = Dali::PathConstrainer::New();
44195     } catch (std::out_of_range& e) {
44196       {
44197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44198       };
44199     } catch (std::exception& e) {
44200       {
44201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44202       };
44203     } catch (Dali::DaliException e) {
44204       {
44205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44206       };
44207     } catch (...) {
44208       {
44209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44210       };
44211     }
44212   }
44213
44214   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44215   return jresult;
44216 }
44217
44218
44219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44220   void * jresult ;
44221   Dali::BaseHandle arg1 ;
44222   Dali::BaseHandle *argp1 ;
44223   Dali::PathConstrainer result;
44224
44225   argp1 = (Dali::BaseHandle *)jarg1;
44226   if (!argp1) {
44227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44228     return 0;
44229   }
44230   arg1 = *argp1;
44231   {
44232     try {
44233       result = Dali::PathConstrainer::DownCast(arg1);
44234     } catch (std::out_of_range& e) {
44235       {
44236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44237       };
44238     } catch (std::exception& e) {
44239       {
44240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44241       };
44242     } catch (Dali::DaliException e) {
44243       {
44244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44245       };
44246     } catch (...) {
44247       {
44248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44249       };
44250     }
44251   }
44252
44253   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44254   return jresult;
44255 }
44256
44257
44258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44259   void * jresult ;
44260   Dali::PathConstrainer *result = 0 ;
44261
44262   {
44263     try {
44264       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44265     } catch (std::out_of_range& e) {
44266       {
44267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44268       };
44269     } catch (std::exception& e) {
44270       {
44271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44272       };
44273     } catch (Dali::DaliException e) {
44274       {
44275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44276       };
44277     } catch (...) {
44278       {
44279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44280       };
44281     }
44282   }
44283
44284   jresult = (void *)result;
44285   return jresult;
44286 }
44287
44288
44289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44290   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44291
44292   arg1 = (Dali::PathConstrainer *)jarg1;
44293   {
44294     try {
44295       delete arg1;
44296     } catch (std::out_of_range& e) {
44297       {
44298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44299       };
44300     } catch (std::exception& e) {
44301       {
44302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44303       };
44304     } catch (Dali::DaliException e) {
44305       {
44306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44307       };
44308     } catch (...) {
44309       {
44310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44311       };
44312     }
44313   }
44314
44315 }
44316
44317
44318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44319   void * jresult ;
44320   Dali::PathConstrainer *arg1 = 0 ;
44321   Dali::PathConstrainer *result = 0 ;
44322
44323   arg1 = (Dali::PathConstrainer *)jarg1;
44324   if (!arg1) {
44325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44326     return 0;
44327   }
44328   {
44329     try {
44330       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44331     } catch (std::out_of_range& e) {
44332       {
44333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44334       };
44335     } catch (std::exception& e) {
44336       {
44337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44338       };
44339     } catch (Dali::DaliException e) {
44340       {
44341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44342       };
44343     } catch (...) {
44344       {
44345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44346       };
44347     }
44348   }
44349
44350   jresult = (void *)result;
44351   return jresult;
44352 }
44353
44354
44355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44356   void * jresult ;
44357   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44358   Dali::PathConstrainer *arg2 = 0 ;
44359   Dali::PathConstrainer *result = 0 ;
44360
44361   arg1 = (Dali::PathConstrainer *)jarg1;
44362   arg2 = (Dali::PathConstrainer *)jarg2;
44363   if (!arg2) {
44364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44365     return 0;
44366   }
44367   {
44368     try {
44369       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44370     } catch (std::out_of_range& e) {
44371       {
44372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44373       };
44374     } catch (std::exception& e) {
44375       {
44376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44377       };
44378     } catch (Dali::DaliException e) {
44379       {
44380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44381       };
44382     } catch (...) {
44383       {
44384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44385       };
44386     }
44387   }
44388
44389   jresult = (void *)result;
44390   return jresult;
44391 }
44392
44393
44394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44395   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44396   SwigValueWrapper< Dali::Property > arg2 ;
44397   SwigValueWrapper< Dali::Property > arg3 ;
44398   Dali::Vector2 *arg4 = 0 ;
44399   Dali::Vector2 *arg5 = 0 ;
44400   Dali::Property *argp2 ;
44401   Dali::Property *argp3 ;
44402
44403   arg1 = (Dali::PathConstrainer *)jarg1;
44404   argp2 = (Dali::Property *)jarg2;
44405   if (!argp2) {
44406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44407     return ;
44408   }
44409   arg2 = *argp2;
44410   argp3 = (Dali::Property *)jarg3;
44411   if (!argp3) {
44412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44413     return ;
44414   }
44415   arg3 = *argp3;
44416   arg4 = (Dali::Vector2 *)jarg4;
44417   if (!arg4) {
44418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44419     return ;
44420   }
44421   arg5 = (Dali::Vector2 *)jarg5;
44422   if (!arg5) {
44423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44424     return ;
44425   }
44426   {
44427     try {
44428       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44429     } catch (std::out_of_range& e) {
44430       {
44431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44432       };
44433     } catch (std::exception& e) {
44434       {
44435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44436       };
44437     } catch (Dali::DaliException e) {
44438       {
44439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44440       };
44441     } catch (...) {
44442       {
44443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44444       };
44445     }
44446   }
44447
44448 }
44449
44450
44451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44452   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44453   SwigValueWrapper< Dali::Property > arg2 ;
44454   SwigValueWrapper< Dali::Property > arg3 ;
44455   Dali::Vector2 *arg4 = 0 ;
44456   Dali::Property *argp2 ;
44457   Dali::Property *argp3 ;
44458
44459   arg1 = (Dali::PathConstrainer *)jarg1;
44460   argp2 = (Dali::Property *)jarg2;
44461   if (!argp2) {
44462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44463     return ;
44464   }
44465   arg2 = *argp2;
44466   argp3 = (Dali::Property *)jarg3;
44467   if (!argp3) {
44468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44469     return ;
44470   }
44471   arg3 = *argp3;
44472   arg4 = (Dali::Vector2 *)jarg4;
44473   if (!arg4) {
44474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44475     return ;
44476   }
44477   {
44478     try {
44479       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44480     } catch (std::out_of_range& e) {
44481       {
44482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44483       };
44484     } catch (std::exception& e) {
44485       {
44486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44487       };
44488     } catch (Dali::DaliException e) {
44489       {
44490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44491       };
44492     } catch (...) {
44493       {
44494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44495       };
44496     }
44497   }
44498
44499 }
44500
44501
44502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44503   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44504   Dali::Handle *arg2 = 0 ;
44505
44506   arg1 = (Dali::PathConstrainer *)jarg1;
44507   arg2 = (Dali::Handle *)jarg2;
44508   if (!arg2) {
44509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44510     return ;
44511   }
44512   {
44513     try {
44514       (arg1)->Remove(*arg2);
44515     } catch (std::out_of_range& e) {
44516       {
44517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44518       };
44519     } catch (std::exception& e) {
44520       {
44521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44522       };
44523     } catch (Dali::DaliException e) {
44524       {
44525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44526       };
44527     } catch (...) {
44528       {
44529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44530       };
44531     }
44532   }
44533
44534 }
44535
44536
44537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44538   int jresult ;
44539   Dali::FittingMode::Type result;
44540
44541   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44542   jresult = (int)result;
44543   return jresult;
44544 }
44545
44546
44547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44548   int jresult ;
44549   Dali::SamplingMode::Type result;
44550
44551   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44552   jresult = (int)result;
44553   return jresult;
44554 }
44555
44556
44557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44558   unsigned int jresult ;
44559   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44560   bool result;
44561
44562   arg1 = (Dali::NativeImageInterface *)jarg1;
44563   {
44564     try {
44565       result = (bool)(arg1)->CreateResource();
44566     } catch (std::out_of_range& e) {
44567       {
44568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44569       };
44570     } catch (std::exception& e) {
44571       {
44572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44573       };
44574     } catch (Dali::DaliException e) {
44575       {
44576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44577       };
44578     } catch (...) {
44579       {
44580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44581       };
44582     }
44583   }
44584
44585   jresult = result;
44586   return jresult;
44587 }
44588
44589
44590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44591   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44592
44593   arg1 = (Dali::NativeImageInterface *)jarg1;
44594   {
44595     try {
44596       (arg1)->DestroyResource();
44597     } catch (std::out_of_range& e) {
44598       {
44599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44600       };
44601     } catch (std::exception& e) {
44602       {
44603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44604       };
44605     } catch (Dali::DaliException e) {
44606       {
44607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44608       };
44609     } catch (...) {
44610       {
44611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44612       };
44613     }
44614   }
44615
44616 }
44617
44618
44619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44620   unsigned int jresult ;
44621   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44622   unsigned int result;
44623
44624   arg1 = (Dali::NativeImageInterface *)jarg1;
44625   {
44626     try {
44627       result = (unsigned int)(arg1)->TargetTexture();
44628     } catch (std::out_of_range& e) {
44629       {
44630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44631       };
44632     } catch (std::exception& e) {
44633       {
44634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44635       };
44636     } catch (Dali::DaliException e) {
44637       {
44638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44639       };
44640     } catch (...) {
44641       {
44642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44643       };
44644     }
44645   }
44646
44647   jresult = result;
44648   return jresult;
44649 }
44650
44651
44652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44653   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44654
44655   arg1 = (Dali::NativeImageInterface *)jarg1;
44656   {
44657     try {
44658       (arg1)->PrepareTexture();
44659     } catch (std::out_of_range& e) {
44660       {
44661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44662       };
44663     } catch (std::exception& e) {
44664       {
44665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44666       };
44667     } catch (Dali::DaliException e) {
44668       {
44669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44670       };
44671     } catch (...) {
44672       {
44673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44674       };
44675     }
44676   }
44677
44678 }
44679
44680
44681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44682   unsigned int jresult ;
44683   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44684   unsigned int result;
44685
44686   arg1 = (Dali::NativeImageInterface *)jarg1;
44687   {
44688     try {
44689       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44690     } catch (std::out_of_range& e) {
44691       {
44692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44693       };
44694     } catch (std::exception& e) {
44695       {
44696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44697       };
44698     } catch (Dali::DaliException e) {
44699       {
44700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44701       };
44702     } catch (...) {
44703       {
44704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44705       };
44706     }
44707   }
44708
44709   jresult = result;
44710   return jresult;
44711 }
44712
44713
44714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44715   unsigned int jresult ;
44716   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44717   unsigned int result;
44718
44719   arg1 = (Dali::NativeImageInterface *)jarg1;
44720   {
44721     try {
44722       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44723     } catch (std::out_of_range& e) {
44724       {
44725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44726       };
44727     } catch (std::exception& e) {
44728       {
44729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44730       };
44731     } catch (Dali::DaliException e) {
44732       {
44733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44734       };
44735     } catch (...) {
44736       {
44737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44738       };
44739     }
44740   }
44741
44742   jresult = result;
44743   return jresult;
44744 }
44745
44746
44747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44748   unsigned int jresult ;
44749   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44750   bool result;
44751
44752   arg1 = (Dali::NativeImageInterface *)jarg1;
44753   {
44754     try {
44755       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44756     } catch (std::out_of_range& e) {
44757       {
44758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44759       };
44760     } catch (std::exception& e) {
44761       {
44762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44763       };
44764     } catch (Dali::DaliException e) {
44765       {
44766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44767       };
44768     } catch (...) {
44769       {
44770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44771       };
44772     }
44773   }
44774
44775   jresult = result;
44776   return jresult;
44777 }
44778
44779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44780   int jresult ;
44781   int result;
44782
44783   result = (int)Dali::CameraActor::Property::TYPE;
44784   jresult = (int)result;
44785   return jresult;
44786 }
44787
44788
44789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44790   int jresult ;
44791   int result;
44792
44793   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44794   jresult = (int)result;
44795   return jresult;
44796 }
44797
44798
44799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44800   int jresult ;
44801   int result;
44802
44803   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44804   jresult = (int)result;
44805   return jresult;
44806 }
44807
44808
44809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44810   int jresult ;
44811   int result;
44812
44813   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44814   jresult = (int)result;
44815   return jresult;
44816 }
44817
44818
44819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44820   int jresult ;
44821   int result;
44822
44823   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
44824   jresult = (int)result;
44825   return jresult;
44826 }
44827
44828
44829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
44830   int jresult ;
44831   int result;
44832
44833   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
44834   jresult = (int)result;
44835   return jresult;
44836 }
44837
44838
44839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
44840   int jresult ;
44841   int result;
44842
44843   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
44844   jresult = (int)result;
44845   return jresult;
44846 }
44847
44848
44849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
44850   int jresult ;
44851   int result;
44852
44853   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
44854   jresult = (int)result;
44855   return jresult;
44856 }
44857
44858
44859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
44860   int jresult ;
44861   int result;
44862
44863   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
44864   jresult = (int)result;
44865   return jresult;
44866 }
44867
44868
44869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
44870   int jresult ;
44871   int result;
44872
44873   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
44874   jresult = (int)result;
44875   return jresult;
44876 }
44877
44878
44879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
44880   int jresult ;
44881   int result;
44882
44883   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
44884   jresult = (int)result;
44885   return jresult;
44886 }
44887
44888
44889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
44890   int jresult ;
44891   int result;
44892
44893   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
44894   jresult = (int)result;
44895   return jresult;
44896 }
44897
44898
44899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
44900   int jresult ;
44901   int result;
44902
44903   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
44904   jresult = (int)result;
44905   return jresult;
44906 }
44907
44908
44909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
44910   int jresult ;
44911   int result;
44912
44913   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
44914   jresult = (int)result;
44915   return jresult;
44916 }
44917
44918
44919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
44920   void * jresult ;
44921   Dali::CameraActor::Property *result = 0 ;
44922
44923   {
44924     try {
44925       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
44926     } catch (std::out_of_range& e) {
44927       {
44928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44929       };
44930     } catch (std::exception& e) {
44931       {
44932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44933       };
44934     } catch (Dali::DaliException e) {
44935       {
44936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44937       };
44938     } catch (...) {
44939       {
44940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44941       };
44942     }
44943   }
44944
44945   jresult = (void *)result;
44946   return jresult;
44947 }
44948
44949
44950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
44951   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
44952
44953   arg1 = (Dali::CameraActor::Property *)jarg1;
44954   {
44955     try {
44956       delete arg1;
44957     } catch (std::out_of_range& e) {
44958       {
44959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44960       };
44961     } catch (std::exception& e) {
44962       {
44963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44964       };
44965     } catch (Dali::DaliException e) {
44966       {
44967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44968       };
44969     } catch (...) {
44970       {
44971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44972       };
44973     }
44974   }
44975
44976 }
44977
44978
44979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44980   void * jresult ;
44981   Dali::CameraActor *result = 0 ;
44982
44983   {
44984     try {
44985       result = (Dali::CameraActor *)new Dali::CameraActor();
44986     } catch (std::out_of_range& e) {
44987       {
44988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44989       };
44990     } catch (std::exception& e) {
44991       {
44992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44993       };
44994     } catch (Dali::DaliException e) {
44995       {
44996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44997       };
44998     } catch (...) {
44999       {
45000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45001       };
45002     }
45003   }
45004
45005   jresult = (void *)result;
45006   return jresult;
45007 }
45008
45009
45010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
45011   void * jresult ;
45012   Dali::CameraActor result;
45013
45014   {
45015     try {
45016       result = Dali::CameraActor::New();
45017     } catch (std::out_of_range& e) {
45018       {
45019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45020       };
45021     } catch (std::exception& e) {
45022       {
45023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45024       };
45025     } catch (Dali::DaliException e) {
45026       {
45027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45028       };
45029     } catch (...) {
45030       {
45031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45032       };
45033     }
45034   }
45035
45036   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45037   return jresult;
45038 }
45039
45040
45041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
45042   void * jresult ;
45043   Dali::Size *arg1 = 0 ;
45044   Dali::CameraActor result;
45045
45046   arg1 = (Dali::Size *)jarg1;
45047   if (!arg1) {
45048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45049     return 0;
45050   }
45051   {
45052     try {
45053       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
45054     } catch (std::out_of_range& e) {
45055       {
45056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45057       };
45058     } catch (std::exception& e) {
45059       {
45060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45061       };
45062     } catch (Dali::DaliException e) {
45063       {
45064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45065       };
45066     } catch (...) {
45067       {
45068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45069       };
45070     }
45071   }
45072
45073   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45074   return jresult;
45075 }
45076
45077
45078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
45079   void * jresult ;
45080   Dali::BaseHandle arg1 ;
45081   Dali::BaseHandle *argp1 ;
45082   Dali::CameraActor result;
45083
45084   argp1 = (Dali::BaseHandle *)jarg1;
45085   if (!argp1) {
45086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45087     return 0;
45088   }
45089   arg1 = *argp1;
45090   {
45091     try {
45092       result = Dali::CameraActor::DownCast(arg1);
45093     } catch (std::out_of_range& e) {
45094       {
45095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45096       };
45097     } catch (std::exception& e) {
45098       {
45099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45100       };
45101     } catch (Dali::DaliException e) {
45102       {
45103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45104       };
45105     } catch (...) {
45106       {
45107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45108       };
45109     }
45110   }
45111
45112   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45113   return jresult;
45114 }
45115
45116
45117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
45118   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45119
45120   arg1 = (Dali::CameraActor *)jarg1;
45121   {
45122     try {
45123       delete arg1;
45124     } catch (std::out_of_range& e) {
45125       {
45126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45127       };
45128     } catch (std::exception& e) {
45129       {
45130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45131       };
45132     } catch (Dali::DaliException e) {
45133       {
45134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45135       };
45136     } catch (...) {
45137       {
45138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45139       };
45140     }
45141   }
45142
45143 }
45144
45145
45146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
45147   void * jresult ;
45148   Dali::CameraActor *arg1 = 0 ;
45149   Dali::CameraActor *result = 0 ;
45150
45151   arg1 = (Dali::CameraActor *)jarg1;
45152   if (!arg1) {
45153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45154     return 0;
45155   }
45156   {
45157     try {
45158       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
45159     } catch (std::out_of_range& e) {
45160       {
45161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45162       };
45163     } catch (std::exception& e) {
45164       {
45165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45166       };
45167     } catch (Dali::DaliException e) {
45168       {
45169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45170       };
45171     } catch (...) {
45172       {
45173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45174       };
45175     }
45176   }
45177
45178   jresult = (void *)result;
45179   return jresult;
45180 }
45181
45182
45183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
45184   void * jresult ;
45185   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45186   Dali::CameraActor *arg2 = 0 ;
45187   Dali::CameraActor *result = 0 ;
45188
45189   arg1 = (Dali::CameraActor *)jarg1;
45190   arg2 = (Dali::CameraActor *)jarg2;
45191   if (!arg2) {
45192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45193     return 0;
45194   }
45195   {
45196     try {
45197       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
45198     } catch (std::out_of_range& e) {
45199       {
45200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45201       };
45202     } catch (std::exception& e) {
45203       {
45204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45205       };
45206     } catch (Dali::DaliException e) {
45207       {
45208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45209       };
45210     } catch (...) {
45211       {
45212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45213       };
45214     }
45215   }
45216
45217   jresult = (void *)result;
45218   return jresult;
45219 }
45220
45221
45222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
45223   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45224   Dali::Camera::Type arg2 ;
45225
45226   arg1 = (Dali::CameraActor *)jarg1;
45227   arg2 = (Dali::Camera::Type)jarg2;
45228   {
45229     try {
45230       (arg1)->SetType(arg2);
45231     } catch (std::out_of_range& e) {
45232       {
45233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45234       };
45235     } catch (std::exception& e) {
45236       {
45237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45238       };
45239     } catch (Dali::DaliException e) {
45240       {
45241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45242       };
45243     } catch (...) {
45244       {
45245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45246       };
45247     }
45248   }
45249
45250 }
45251
45252
45253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
45254   int jresult ;
45255   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45256   Dali::Camera::Type result;
45257
45258   arg1 = (Dali::CameraActor *)jarg1;
45259   {
45260     try {
45261       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
45262     } catch (std::out_of_range& e) {
45263       {
45264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45265       };
45266     } catch (std::exception& e) {
45267       {
45268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45269       };
45270     } catch (Dali::DaliException e) {
45271       {
45272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45273       };
45274     } catch (...) {
45275       {
45276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45277       };
45278     }
45279   }
45280
45281   jresult = (int)result;
45282   return jresult;
45283 }
45284
45285
45286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45287   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45288   Dali::Camera::ProjectionMode arg2 ;
45289
45290   arg1 = (Dali::CameraActor *)jarg1;
45291   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45292   {
45293     try {
45294       (arg1)->SetProjectionMode(arg2);
45295     } catch (std::out_of_range& e) {
45296       {
45297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45298       };
45299     } catch (std::exception& e) {
45300       {
45301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45302       };
45303     } catch (Dali::DaliException e) {
45304       {
45305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45306       };
45307     } catch (...) {
45308       {
45309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45310       };
45311     }
45312   }
45313
45314 }
45315
45316
45317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45318   int jresult ;
45319   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45320   Dali::Camera::ProjectionMode result;
45321
45322   arg1 = (Dali::CameraActor *)jarg1;
45323   {
45324     try {
45325       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45326     } catch (std::out_of_range& e) {
45327       {
45328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45329       };
45330     } catch (std::exception& e) {
45331       {
45332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45333       };
45334     } catch (Dali::DaliException e) {
45335       {
45336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45337       };
45338     } catch (...) {
45339       {
45340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45341       };
45342     }
45343   }
45344
45345   jresult = (int)result;
45346   return jresult;
45347 }
45348
45349
45350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45351   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45352   float arg2 ;
45353
45354   arg1 = (Dali::CameraActor *)jarg1;
45355   arg2 = (float)jarg2;
45356   {
45357     try {
45358       (arg1)->SetFieldOfView(arg2);
45359     } catch (std::out_of_range& e) {
45360       {
45361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45362       };
45363     } catch (std::exception& e) {
45364       {
45365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45366       };
45367     } catch (Dali::DaliException e) {
45368       {
45369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45370       };
45371     } catch (...) {
45372       {
45373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45374       };
45375     }
45376   }
45377
45378 }
45379
45380
45381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45382   float jresult ;
45383   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45384   float result;
45385
45386   arg1 = (Dali::CameraActor *)jarg1;
45387   {
45388     try {
45389       result = (float)(arg1)->GetFieldOfView();
45390     } catch (std::out_of_range& e) {
45391       {
45392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45393       };
45394     } catch (std::exception& e) {
45395       {
45396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45397       };
45398     } catch (Dali::DaliException e) {
45399       {
45400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45401       };
45402     } catch (...) {
45403       {
45404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45405       };
45406     }
45407   }
45408
45409   jresult = result;
45410   return jresult;
45411 }
45412
45413
45414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45415   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45416   float arg2 ;
45417
45418   arg1 = (Dali::CameraActor *)jarg1;
45419   arg2 = (float)jarg2;
45420   {
45421     try {
45422       (arg1)->SetAspectRatio(arg2);
45423     } catch (std::out_of_range& e) {
45424       {
45425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45426       };
45427     } catch (std::exception& e) {
45428       {
45429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45430       };
45431     } catch (Dali::DaliException e) {
45432       {
45433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45434       };
45435     } catch (...) {
45436       {
45437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45438       };
45439     }
45440   }
45441
45442 }
45443
45444
45445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45446   float jresult ;
45447   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45448   float result;
45449
45450   arg1 = (Dali::CameraActor *)jarg1;
45451   {
45452     try {
45453       result = (float)(arg1)->GetAspectRatio();
45454     } catch (std::out_of_range& e) {
45455       {
45456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45457       };
45458     } catch (std::exception& e) {
45459       {
45460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45461       };
45462     } catch (Dali::DaliException e) {
45463       {
45464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45465       };
45466     } catch (...) {
45467       {
45468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45469       };
45470     }
45471   }
45472
45473   jresult = result;
45474   return jresult;
45475 }
45476
45477
45478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45479   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45480   float arg2 ;
45481
45482   arg1 = (Dali::CameraActor *)jarg1;
45483   arg2 = (float)jarg2;
45484   {
45485     try {
45486       (arg1)->SetNearClippingPlane(arg2);
45487     } catch (std::out_of_range& e) {
45488       {
45489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45490       };
45491     } catch (std::exception& e) {
45492       {
45493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45494       };
45495     } catch (Dali::DaliException e) {
45496       {
45497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45498       };
45499     } catch (...) {
45500       {
45501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45502       };
45503     }
45504   }
45505
45506 }
45507
45508
45509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45510   float jresult ;
45511   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45512   float result;
45513
45514   arg1 = (Dali::CameraActor *)jarg1;
45515   {
45516     try {
45517       result = (float)(arg1)->GetNearClippingPlane();
45518     } catch (std::out_of_range& e) {
45519       {
45520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45521       };
45522     } catch (std::exception& e) {
45523       {
45524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45525       };
45526     } catch (Dali::DaliException e) {
45527       {
45528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45529       };
45530     } catch (...) {
45531       {
45532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45533       };
45534     }
45535   }
45536
45537   jresult = result;
45538   return jresult;
45539 }
45540
45541
45542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45543   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45544   float arg2 ;
45545
45546   arg1 = (Dali::CameraActor *)jarg1;
45547   arg2 = (float)jarg2;
45548   {
45549     try {
45550       (arg1)->SetFarClippingPlane(arg2);
45551     } catch (std::out_of_range& e) {
45552       {
45553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45554       };
45555     } catch (std::exception& e) {
45556       {
45557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45558       };
45559     } catch (Dali::DaliException e) {
45560       {
45561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45562       };
45563     } catch (...) {
45564       {
45565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45566       };
45567     }
45568   }
45569
45570 }
45571
45572
45573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45574   float jresult ;
45575   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45576   float result;
45577
45578   arg1 = (Dali::CameraActor *)jarg1;
45579   {
45580     try {
45581       result = (float)(arg1)->GetFarClippingPlane();
45582     } catch (std::out_of_range& e) {
45583       {
45584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45585       };
45586     } catch (std::exception& e) {
45587       {
45588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45589       };
45590     } catch (Dali::DaliException e) {
45591       {
45592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45593       };
45594     } catch (...) {
45595       {
45596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45597       };
45598     }
45599   }
45600
45601   jresult = result;
45602   return jresult;
45603 }
45604
45605
45606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45607   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45608   Dali::Vector3 *arg2 = 0 ;
45609
45610   arg1 = (Dali::CameraActor *)jarg1;
45611   arg2 = (Dali::Vector3 *)jarg2;
45612   if (!arg2) {
45613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45614     return ;
45615   }
45616   {
45617     try {
45618       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45619     } catch (std::out_of_range& e) {
45620       {
45621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45622       };
45623     } catch (std::exception& e) {
45624       {
45625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45626       };
45627     } catch (Dali::DaliException e) {
45628       {
45629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45630       };
45631     } catch (...) {
45632       {
45633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45634       };
45635     }
45636   }
45637
45638 }
45639
45640
45641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45642   void * jresult ;
45643   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45644   Dali::Vector3 result;
45645
45646   arg1 = (Dali::CameraActor *)jarg1;
45647   {
45648     try {
45649       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45650     } catch (std::out_of_range& e) {
45651       {
45652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45653       };
45654     } catch (std::exception& e) {
45655       {
45656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45657       };
45658     } catch (Dali::DaliException e) {
45659       {
45660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45661       };
45662     } catch (...) {
45663       {
45664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45665       };
45666     }
45667   }
45668
45669   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45670   return jresult;
45671 }
45672
45673
45674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45675   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45676   bool arg2 ;
45677
45678   arg1 = (Dali::CameraActor *)jarg1;
45679   arg2 = jarg2 ? true : false;
45680   {
45681     try {
45682       (arg1)->SetInvertYAxis(arg2);
45683     } catch (std::out_of_range& e) {
45684       {
45685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45686       };
45687     } catch (std::exception& e) {
45688       {
45689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45690       };
45691     } catch (Dali::DaliException e) {
45692       {
45693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45694       };
45695     } catch (...) {
45696       {
45697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45698       };
45699     }
45700   }
45701
45702 }
45703
45704
45705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45706   unsigned int jresult ;
45707   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45708   bool result;
45709
45710   arg1 = (Dali::CameraActor *)jarg1;
45711   {
45712     try {
45713       result = (bool)(arg1)->GetInvertYAxis();
45714     } catch (std::out_of_range& e) {
45715       {
45716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45717       };
45718     } catch (std::exception& e) {
45719       {
45720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45721       };
45722     } catch (Dali::DaliException e) {
45723       {
45724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45725       };
45726     } catch (...) {
45727       {
45728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45729       };
45730     }
45731   }
45732
45733   jresult = result;
45734   return jresult;
45735 }
45736
45737
45738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45739   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45740   Dali::Size *arg2 = 0 ;
45741
45742   arg1 = (Dali::CameraActor *)jarg1;
45743   arg2 = (Dali::Size *)jarg2;
45744   if (!arg2) {
45745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45746     return ;
45747   }
45748   {
45749     try {
45750       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45751     } catch (std::out_of_range& e) {
45752       {
45753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45754       };
45755     } catch (std::exception& e) {
45756       {
45757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45758       };
45759     } catch (Dali::DaliException e) {
45760       {
45761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45762       };
45763     } catch (...) {
45764       {
45765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45766       };
45767     }
45768   }
45769
45770 }
45771
45772
45773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45774   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45775   Dali::Size *arg2 = 0 ;
45776
45777   arg1 = (Dali::CameraActor *)jarg1;
45778   arg2 = (Dali::Size *)jarg2;
45779   if (!arg2) {
45780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45781     return ;
45782   }
45783   {
45784     try {
45785       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45786     } catch (std::out_of_range& e) {
45787       {
45788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45789       };
45790     } catch (std::exception& e) {
45791       {
45792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45793       };
45794     } catch (Dali::DaliException e) {
45795       {
45796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45797       };
45798     } catch (...) {
45799       {
45800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45801       };
45802     }
45803   }
45804
45805 }
45806
45807
45808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45809   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45810   float arg2 ;
45811   float arg3 ;
45812   float arg4 ;
45813   float arg5 ;
45814   float arg6 ;
45815   float arg7 ;
45816
45817   arg1 = (Dali::CameraActor *)jarg1;
45818   arg2 = (float)jarg2;
45819   arg3 = (float)jarg3;
45820   arg4 = (float)jarg4;
45821   arg5 = (float)jarg5;
45822   arg6 = (float)jarg6;
45823   arg7 = (float)jarg7;
45824   {
45825     try {
45826       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
45827     } catch (std::out_of_range& e) {
45828       {
45829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45830       };
45831     } catch (std::exception& e) {
45832       {
45833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45834       };
45835     } catch (Dali::DaliException e) {
45836       {
45837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45838       };
45839     } catch (...) {
45840       {
45841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45842       };
45843     }
45844   }
45845
45846 }
45847
45848
45849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
45850   void * jresult ;
45851   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45852
45853   {
45854     try {
45855       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
45856     } catch (std::out_of_range& e) {
45857       {
45858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45859       };
45860     } catch (std::exception& e) {
45861       {
45862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45863       };
45864     } catch (Dali::DaliException e) {
45865       {
45866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45867       };
45868     } catch (...) {
45869       {
45870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45871       };
45872     }
45873   }
45874
45875   jresult = (void *)result;
45876   return jresult;
45877 }
45878
45879
45880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
45881   void * jresult ;
45882   std::string arg1 ;
45883   Dali::Property::Value arg2 ;
45884   Dali::Property::Value *argp2 ;
45885   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45886
45887   if (!jarg1) {
45888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45889     return 0;
45890   }
45891   (&arg1)->assign(jarg1);
45892   argp2 = (Dali::Property::Value *)jarg2;
45893   if (!argp2) {
45894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
45895     return 0;
45896   }
45897   arg2 = *argp2;
45898   {
45899     try {
45900       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
45901     } catch (std::out_of_range& e) {
45902       {
45903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45904       };
45905     } catch (std::exception& e) {
45906       {
45907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45908       };
45909     } catch (Dali::DaliException e) {
45910       {
45911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45912       };
45913     } catch (...) {
45914       {
45915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45916       };
45917     }
45918   }
45919
45920   jresult = (void *)result;
45921   return jresult;
45922 }
45923
45924
45925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
45926   void * jresult ;
45927   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
45928   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45929
45930   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45931   if (!arg1) {
45932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
45933     return 0;
45934   }
45935   {
45936     try {
45937       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);
45938     } catch (std::out_of_range& e) {
45939       {
45940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45941       };
45942     } catch (std::exception& e) {
45943       {
45944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45945       };
45946     } catch (Dali::DaliException e) {
45947       {
45948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45949       };
45950     } catch (...) {
45951       {
45952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45953       };
45954     }
45955   }
45956
45957   jresult = (void *)result;
45958   return jresult;
45959 }
45960
45961
45962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
45963   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45964   std::string *arg2 = 0 ;
45965
45966   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45967   if (!jarg2) {
45968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45969     return ;
45970   }
45971   std::string arg2_str(jarg2);
45972   arg2 = &arg2_str;
45973   if (arg1) (arg1)->first = *arg2;
45974
45975   //argout typemap for const std::string&
45976
45977 }
45978
45979
45980 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
45981   char * jresult ;
45982   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45983   std::string *result = 0 ;
45984
45985   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45986   result = (std::string *) & ((arg1)->first);
45987   jresult = SWIG_csharp_string_callback(result->c_str());
45988   return jresult;
45989 }
45990
45991
45992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
45993   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45994   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
45995
45996   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45997   arg2 = (Dali::Property::Value *)jarg2;
45998   if (arg1) (arg1)->second = *arg2;
45999 }
46000
46001
46002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
46003   void * jresult ;
46004   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46005   Dali::Property::Value *result = 0 ;
46006
46007   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46008   result = (Dali::Property::Value *)& ((arg1)->second);
46009   jresult = (void *)result;
46010   return jresult;
46011 }
46012
46013
46014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
46015   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46016
46017   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46018   {
46019     try {
46020       delete arg1;
46021     } catch (std::out_of_range& e) {
46022       {
46023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46024       };
46025     } catch (std::exception& e) {
46026       {
46027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46028       };
46029     } catch (Dali::DaliException e) {
46030       {
46031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46032       };
46033     } catch (...) {
46034       {
46035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46036       };
46037     }
46038   }
46039
46040 }
46041
46042
46043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
46044   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46045
46046   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46047   {
46048     try {
46049       (arg1)->clear();
46050     } catch (std::out_of_range& e) {
46051       {
46052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46053       };
46054     } catch (std::exception& e) {
46055       {
46056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46057       };
46058     } catch (Dali::DaliException e) {
46059       {
46060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46061       };
46062     } catch (...) {
46063       {
46064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46065       };
46066     }
46067   }
46068
46069 }
46070
46071
46072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
46073   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46074   Dali::TouchPoint *arg2 = 0 ;
46075
46076   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46077   arg2 = (Dali::TouchPoint *)jarg2;
46078   if (!arg2) {
46079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46080     return ;
46081   }
46082   {
46083     try {
46084       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
46085     } catch (std::out_of_range& e) {
46086       {
46087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46088       };
46089     } catch (std::exception& e) {
46090       {
46091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46092       };
46093     } catch (Dali::DaliException e) {
46094       {
46095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46096       };
46097     } catch (...) {
46098       {
46099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46100       };
46101     }
46102   }
46103
46104 }
46105
46106
46107 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
46108   unsigned long jresult ;
46109   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46110   std::vector< Dali::TouchPoint >::size_type result;
46111
46112   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46113   {
46114     try {
46115       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
46116     } catch (std::out_of_range& e) {
46117       {
46118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46119       };
46120     } catch (std::exception& e) {
46121       {
46122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46123       };
46124     } catch (Dali::DaliException e) {
46125       {
46126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46127       };
46128     } catch (...) {
46129       {
46130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46131       };
46132     }
46133   }
46134
46135   jresult = (unsigned long)result;
46136   return jresult;
46137 }
46138
46139
46140 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
46141   unsigned long jresult ;
46142   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46143   std::vector< Dali::TouchPoint >::size_type result;
46144
46145   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46146   {
46147     try {
46148       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
46149     } catch (std::out_of_range& e) {
46150       {
46151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46152       };
46153     } catch (std::exception& e) {
46154       {
46155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46156       };
46157     } catch (Dali::DaliException e) {
46158       {
46159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46160       };
46161     } catch (...) {
46162       {
46163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46164       };
46165     }
46166   }
46167
46168   jresult = (unsigned long)result;
46169   return jresult;
46170 }
46171
46172
46173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
46174   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46175   std::vector< Dali::TouchPoint >::size_type arg2 ;
46176
46177   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46178   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
46179   {
46180     try {
46181       (arg1)->reserve(arg2);
46182     } catch (std::out_of_range& e) {
46183       {
46184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46185       };
46186     } catch (std::exception& e) {
46187       {
46188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46189       };
46190     } catch (Dali::DaliException e) {
46191       {
46192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46193       };
46194     } catch (...) {
46195       {
46196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46197       };
46198     }
46199   }
46200
46201 }
46202
46203
46204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
46205   void * jresult ;
46206   std::vector< Dali::TouchPoint > *result = 0 ;
46207
46208   {
46209     try {
46210       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
46211     } catch (std::out_of_range& e) {
46212       {
46213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46214       };
46215     } catch (std::exception& e) {
46216       {
46217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46218       };
46219     } catch (Dali::DaliException e) {
46220       {
46221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46222       };
46223     } catch (...) {
46224       {
46225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46226       };
46227     }
46228   }
46229
46230   jresult = (void *)result;
46231   return jresult;
46232 }
46233
46234
46235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
46236   void * jresult ;
46237   std::vector< Dali::TouchPoint > *arg1 = 0 ;
46238   std::vector< Dali::TouchPoint > *result = 0 ;
46239
46240   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46241   if (!arg1) {
46242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46243     return 0;
46244   }
46245   {
46246     try {
46247       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
46248     } catch (std::out_of_range& e) {
46249       {
46250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46251       };
46252     } catch (std::exception& e) {
46253       {
46254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46255       };
46256     } catch (Dali::DaliException e) {
46257       {
46258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46259       };
46260     } catch (...) {
46261       {
46262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46263       };
46264     }
46265   }
46266
46267   jresult = (void *)result;
46268   return jresult;
46269 }
46270
46271
46272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46273   void * jresult ;
46274   int arg1 ;
46275   std::vector< Dali::TouchPoint > *result = 0 ;
46276
46277   arg1 = (int)jarg1;
46278   {
46279     try {
46280       try {
46281         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46282       }
46283       catch(std::out_of_range &_e) {
46284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46285         return 0;
46286       }
46287
46288     } catch (std::out_of_range& e) {
46289       {
46290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46291       };
46292     } catch (std::exception& e) {
46293       {
46294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46295       };
46296     } catch (Dali::DaliException e) {
46297       {
46298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46299       };
46300     } catch (...) {
46301       {
46302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46303       };
46304     }
46305   }
46306
46307   jresult = (void *)result;
46308   return jresult;
46309 }
46310
46311
46312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46313   void * jresult ;
46314   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46315   int arg2 ;
46316   SwigValueWrapper< Dali::TouchPoint > result;
46317
46318   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46319   arg2 = (int)jarg2;
46320   {
46321     try {
46322       try {
46323         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46324       }
46325       catch(std::out_of_range &_e) {
46326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46327         return 0;
46328       }
46329
46330     } catch (std::out_of_range& e) {
46331       {
46332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46333       };
46334     } catch (std::exception& e) {
46335       {
46336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46337       };
46338     } catch (Dali::DaliException e) {
46339       {
46340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46341       };
46342     } catch (...) {
46343       {
46344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46345       };
46346     }
46347   }
46348
46349   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46350   return jresult;
46351 }
46352
46353
46354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46355   void * jresult ;
46356   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46357   int arg2 ;
46358   Dali::TouchPoint *result = 0 ;
46359
46360   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46361   arg2 = (int)jarg2;
46362   {
46363     try {
46364       try {
46365         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46366       }
46367       catch(std::out_of_range &_e) {
46368         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46369         return 0;
46370       }
46371
46372     } catch (std::out_of_range& e) {
46373       {
46374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46375       };
46376     } catch (std::exception& e) {
46377       {
46378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46379       };
46380     } catch (Dali::DaliException e) {
46381       {
46382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46383       };
46384     } catch (...) {
46385       {
46386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46387       };
46388     }
46389   }
46390
46391   jresult = (void *)result;
46392   return jresult;
46393 }
46394
46395
46396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46397   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46398   int arg2 ;
46399   Dali::TouchPoint *arg3 = 0 ;
46400
46401   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46402   arg2 = (int)jarg2;
46403   arg3 = (Dali::TouchPoint *)jarg3;
46404   if (!arg3) {
46405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46406     return ;
46407   }
46408   {
46409     try {
46410       try {
46411         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46412       }
46413       catch(std::out_of_range &_e) {
46414         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46415         return ;
46416       }
46417
46418     } catch (std::out_of_range& e) {
46419       {
46420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46421       };
46422     } catch (std::exception& e) {
46423       {
46424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46425       };
46426     } catch (Dali::DaliException e) {
46427       {
46428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46429       };
46430     } catch (...) {
46431       {
46432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46433       };
46434     }
46435   }
46436
46437 }
46438
46439
46440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46441   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46442   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46443
46444   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46445   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46446   if (!arg2) {
46447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46448     return ;
46449   }
46450   {
46451     try {
46452       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46453     } catch (std::out_of_range& e) {
46454       {
46455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46456       };
46457     } catch (std::exception& e) {
46458       {
46459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46460       };
46461     } catch (Dali::DaliException e) {
46462       {
46463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46464       };
46465     } catch (...) {
46466       {
46467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46468       };
46469     }
46470   }
46471
46472 }
46473
46474
46475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46476   void * jresult ;
46477   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46478   int arg2 ;
46479   int arg3 ;
46480   std::vector< Dali::TouchPoint > *result = 0 ;
46481
46482   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46483   arg2 = (int)jarg2;
46484   arg3 = (int)jarg3;
46485   {
46486     try {
46487       try {
46488         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46489       }
46490       catch(std::out_of_range &_e) {
46491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46492         return 0;
46493       }
46494       catch(std::invalid_argument &_e) {
46495         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46496         return 0;
46497       }
46498
46499     } catch (std::out_of_range& e) {
46500       {
46501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46502       };
46503     } catch (std::exception& e) {
46504       {
46505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46506       };
46507     } catch (Dali::DaliException e) {
46508       {
46509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46510       };
46511     } catch (...) {
46512       {
46513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46514       };
46515     }
46516   }
46517
46518   jresult = (void *)result;
46519   return jresult;
46520 }
46521
46522
46523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46524   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46525   int arg2 ;
46526   Dali::TouchPoint *arg3 = 0 ;
46527
46528   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46529   arg2 = (int)jarg2;
46530   arg3 = (Dali::TouchPoint *)jarg3;
46531   if (!arg3) {
46532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46533     return ;
46534   }
46535   {
46536     try {
46537       try {
46538         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46539       }
46540       catch(std::out_of_range &_e) {
46541         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46542         return ;
46543       }
46544
46545     } catch (std::out_of_range& e) {
46546       {
46547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46548       };
46549     } catch (std::exception& e) {
46550       {
46551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46552       };
46553     } catch (Dali::DaliException e) {
46554       {
46555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46556       };
46557     } catch (...) {
46558       {
46559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46560       };
46561     }
46562   }
46563
46564 }
46565
46566
46567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46568   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46569   int arg2 ;
46570   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46571
46572   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46573   arg2 = (int)jarg2;
46574   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46575   if (!arg3) {
46576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46577     return ;
46578   }
46579   {
46580     try {
46581       try {
46582         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46583       }
46584       catch(std::out_of_range &_e) {
46585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46586         return ;
46587       }
46588
46589     } catch (std::out_of_range& e) {
46590       {
46591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46592       };
46593     } catch (std::exception& e) {
46594       {
46595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46596       };
46597     } catch (Dali::DaliException e) {
46598       {
46599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46600       };
46601     } catch (...) {
46602       {
46603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46604       };
46605     }
46606   }
46607
46608 }
46609
46610
46611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46612   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46613   int arg2 ;
46614
46615   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46616   arg2 = (int)jarg2;
46617   {
46618     try {
46619       try {
46620         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46621       }
46622       catch(std::out_of_range &_e) {
46623         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46624         return ;
46625       }
46626
46627     } catch (std::out_of_range& e) {
46628       {
46629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46630       };
46631     } catch (std::exception& e) {
46632       {
46633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46634       };
46635     } catch (Dali::DaliException e) {
46636       {
46637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46638       };
46639     } catch (...) {
46640       {
46641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46642       };
46643     }
46644   }
46645
46646 }
46647
46648
46649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46650   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46651   int arg2 ;
46652   int arg3 ;
46653
46654   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46655   arg2 = (int)jarg2;
46656   arg3 = (int)jarg3;
46657   {
46658     try {
46659       try {
46660         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46661       }
46662       catch(std::out_of_range &_e) {
46663         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46664         return ;
46665       }
46666       catch(std::invalid_argument &_e) {
46667         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46668         return ;
46669       }
46670
46671     } catch (std::out_of_range& e) {
46672       {
46673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46674       };
46675     } catch (std::exception& e) {
46676       {
46677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46678       };
46679     } catch (Dali::DaliException e) {
46680       {
46681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46682       };
46683     } catch (...) {
46684       {
46685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46686       };
46687     }
46688   }
46689
46690 }
46691
46692
46693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46694   void * jresult ;
46695   Dali::TouchPoint *arg1 = 0 ;
46696   int arg2 ;
46697   std::vector< Dali::TouchPoint > *result = 0 ;
46698
46699   arg1 = (Dali::TouchPoint *)jarg1;
46700   if (!arg1) {
46701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46702     return 0;
46703   }
46704   arg2 = (int)jarg2;
46705   {
46706     try {
46707       try {
46708         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46709       }
46710       catch(std::out_of_range &_e) {
46711         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46712         return 0;
46713       }
46714
46715     } catch (std::out_of_range& e) {
46716       {
46717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46718       };
46719     } catch (std::exception& e) {
46720       {
46721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46722       };
46723     } catch (Dali::DaliException e) {
46724       {
46725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46726       };
46727     } catch (...) {
46728       {
46729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46730       };
46731     }
46732   }
46733
46734   jresult = (void *)result;
46735   return jresult;
46736 }
46737
46738
46739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46740   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46741
46742   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46743   {
46744     try {
46745       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46746     } catch (std::out_of_range& e) {
46747       {
46748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46749       };
46750     } catch (std::exception& e) {
46751       {
46752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46753       };
46754     } catch (Dali::DaliException e) {
46755       {
46756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46757       };
46758     } catch (...) {
46759       {
46760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46761       };
46762     }
46763   }
46764
46765 }
46766
46767
46768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46769   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46770   int arg2 ;
46771   int arg3 ;
46772
46773   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46774   arg2 = (int)jarg2;
46775   arg3 = (int)jarg3;
46776   {
46777     try {
46778       try {
46779         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46780       }
46781       catch(std::out_of_range &_e) {
46782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46783         return ;
46784       }
46785       catch(std::invalid_argument &_e) {
46786         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46787         return ;
46788       }
46789
46790     } catch (std::out_of_range& e) {
46791       {
46792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46793       };
46794     } catch (std::exception& e) {
46795       {
46796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46797       };
46798     } catch (Dali::DaliException e) {
46799       {
46800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46801       };
46802     } catch (...) {
46803       {
46804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46805       };
46806     }
46807   }
46808
46809 }
46810
46811
46812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46813   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46814   int arg2 ;
46815   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46816
46817   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46818   arg2 = (int)jarg2;
46819   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46820   if (!arg3) {
46821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46822     return ;
46823   }
46824   {
46825     try {
46826       try {
46827         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46828       }
46829       catch(std::out_of_range &_e) {
46830         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46831         return ;
46832       }
46833
46834     } catch (std::out_of_range& e) {
46835       {
46836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46837       };
46838     } catch (std::exception& e) {
46839       {
46840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46841       };
46842     } catch (Dali::DaliException e) {
46843       {
46844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46845       };
46846     } catch (...) {
46847       {
46848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46849       };
46850     }
46851   }
46852
46853 }
46854
46855
46856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
46857   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46858
46859   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46860   {
46861     try {
46862       delete arg1;
46863     } catch (std::out_of_range& e) {
46864       {
46865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46866       };
46867     } catch (std::exception& e) {
46868       {
46869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46870       };
46871     } catch (Dali::DaliException e) {
46872       {
46873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46874       };
46875     } catch (...) {
46876       {
46877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46878       };
46879     }
46880   }
46881
46882 }
46883
46884
46885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
46886   void * jresult ;
46887   Dali::Rect< int > *result = 0 ;
46888
46889   {
46890     try {
46891       result = (Dali::Rect< int > *)new Dali::Rect< int >();
46892     } catch (std::out_of_range& e) {
46893       {
46894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46895       };
46896     } catch (std::exception& e) {
46897       {
46898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46899       };
46900     } catch (Dali::DaliException e) {
46901       {
46902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46903       };
46904     } catch (...) {
46905       {
46906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46907       };
46908     }
46909   }
46910
46911   jresult = (void *)result;
46912   return jresult;
46913 }
46914
46915
46916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
46917   void * jresult ;
46918   int arg1 ;
46919   int arg2 ;
46920   int arg3 ;
46921   int arg4 ;
46922   Dali::Rect< int > *result = 0 ;
46923
46924   arg1 = (int)jarg1;
46925   arg2 = (int)jarg2;
46926   arg3 = (int)jarg3;
46927   arg4 = (int)jarg4;
46928   {
46929     try {
46930       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
46931     } catch (std::out_of_range& e) {
46932       {
46933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46934       };
46935     } catch (std::exception& e) {
46936       {
46937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46938       };
46939     } catch (Dali::DaliException e) {
46940       {
46941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46942       };
46943     } catch (...) {
46944       {
46945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46946       };
46947     }
46948   }
46949
46950   jresult = (void *)result;
46951   return jresult;
46952 }
46953
46954
46955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
46956   void * jresult ;
46957   Dali::Rect< int > *arg1 = 0 ;
46958   Dali::Rect< int > *result = 0 ;
46959
46960   arg1 = (Dali::Rect< int > *)jarg1;
46961   if (!arg1) {
46962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46963     return 0;
46964   }
46965   {
46966     try {
46967       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
46968     } catch (std::out_of_range& e) {
46969       {
46970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46971       };
46972     } catch (std::exception& e) {
46973       {
46974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46975       };
46976     } catch (Dali::DaliException e) {
46977       {
46978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46979       };
46980     } catch (...) {
46981       {
46982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46983       };
46984     }
46985   }
46986
46987   jresult = (void *)result;
46988   return jresult;
46989 }
46990
46991
46992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
46993   void * jresult ;
46994   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46995   Dali::Rect< int > *arg2 = 0 ;
46996   Dali::Rect< int > *result = 0 ;
46997
46998   arg1 = (Dali::Rect< int > *)jarg1;
46999   arg2 = (Dali::Rect< int > *)jarg2;
47000   if (!arg2) {
47001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47002     return 0;
47003   }
47004   {
47005     try {
47006       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
47007     } catch (std::out_of_range& e) {
47008       {
47009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47010       };
47011     } catch (std::exception& e) {
47012       {
47013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47014       };
47015     } catch (Dali::DaliException e) {
47016       {
47017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47018       };
47019     } catch (...) {
47020       {
47021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47022       };
47023     }
47024   }
47025
47026   jresult = (void *)result;
47027   return jresult;
47028 }
47029
47030
47031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
47032   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47033   int arg2 ;
47034   int arg3 ;
47035   int arg4 ;
47036   int arg5 ;
47037
47038   arg1 = (Dali::Rect< int > *)jarg1;
47039   arg2 = (int)jarg2;
47040   arg3 = (int)jarg3;
47041   arg4 = (int)jarg4;
47042   arg5 = (int)jarg5;
47043   {
47044     try {
47045       (arg1)->Set(arg2,arg3,arg4,arg5);
47046     } catch (std::out_of_range& e) {
47047       {
47048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47049       };
47050     } catch (std::exception& e) {
47051       {
47052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47053       };
47054     } catch (Dali::DaliException e) {
47055       {
47056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47057       };
47058     } catch (...) {
47059       {
47060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47061       };
47062     }
47063   }
47064
47065 }
47066
47067
47068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
47069   unsigned int jresult ;
47070   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47071   bool result;
47072
47073   arg1 = (Dali::Rect< int > *)jarg1;
47074   {
47075     try {
47076       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
47077     } catch (std::out_of_range& e) {
47078       {
47079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47080       };
47081     } catch (std::exception& e) {
47082       {
47083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47084       };
47085     } catch (Dali::DaliException e) {
47086       {
47087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47088       };
47089     } catch (...) {
47090       {
47091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47092       };
47093     }
47094   }
47095
47096   jresult = result;
47097   return jresult;
47098 }
47099
47100
47101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
47102   int jresult ;
47103   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47104   int result;
47105
47106   arg1 = (Dali::Rect< int > *)jarg1;
47107   {
47108     try {
47109       result = (int)((Dali::Rect< int > const *)arg1)->Left();
47110     } catch (std::out_of_range& e) {
47111       {
47112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47113       };
47114     } catch (std::exception& e) {
47115       {
47116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47117       };
47118     } catch (Dali::DaliException e) {
47119       {
47120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47121       };
47122     } catch (...) {
47123       {
47124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47125       };
47126     }
47127   }
47128
47129   jresult = result;
47130   return jresult;
47131 }
47132
47133
47134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
47135   int jresult ;
47136   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47137   int result;
47138
47139   arg1 = (Dali::Rect< int > *)jarg1;
47140   {
47141     try {
47142       result = (int)((Dali::Rect< int > const *)arg1)->Right();
47143     } catch (std::out_of_range& e) {
47144       {
47145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47146       };
47147     } catch (std::exception& e) {
47148       {
47149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47150       };
47151     } catch (Dali::DaliException e) {
47152       {
47153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47154       };
47155     } catch (...) {
47156       {
47157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47158       };
47159     }
47160   }
47161
47162   jresult = result;
47163   return jresult;
47164 }
47165
47166
47167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
47168   int jresult ;
47169   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47170   int result;
47171
47172   arg1 = (Dali::Rect< int > *)jarg1;
47173   {
47174     try {
47175       result = (int)((Dali::Rect< int > const *)arg1)->Top();
47176     } catch (std::out_of_range& e) {
47177       {
47178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47179       };
47180     } catch (std::exception& e) {
47181       {
47182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47183       };
47184     } catch (Dali::DaliException e) {
47185       {
47186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47187       };
47188     } catch (...) {
47189       {
47190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47191       };
47192     }
47193   }
47194
47195   jresult = result;
47196   return jresult;
47197 }
47198
47199
47200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
47201   int jresult ;
47202   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47203   int result;
47204
47205   arg1 = (Dali::Rect< int > *)jarg1;
47206   {
47207     try {
47208       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
47209     } catch (std::out_of_range& e) {
47210       {
47211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47212       };
47213     } catch (std::exception& e) {
47214       {
47215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47216       };
47217     } catch (Dali::DaliException e) {
47218       {
47219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47220       };
47221     } catch (...) {
47222       {
47223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47224       };
47225     }
47226   }
47227
47228   jresult = result;
47229   return jresult;
47230 }
47231
47232
47233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
47234   int jresult ;
47235   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47236   int result;
47237
47238   arg1 = (Dali::Rect< int > *)jarg1;
47239   {
47240     try {
47241       result = (int)((Dali::Rect< int > const *)arg1)->Area();
47242     } catch (std::out_of_range& e) {
47243       {
47244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47245       };
47246     } catch (std::exception& e) {
47247       {
47248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47249       };
47250     } catch (Dali::DaliException e) {
47251       {
47252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47253       };
47254     } catch (...) {
47255       {
47256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47257       };
47258     }
47259   }
47260
47261   jresult = result;
47262   return jresult;
47263 }
47264
47265
47266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
47267   unsigned int jresult ;
47268   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47269   Dali::Rect< int > *arg2 = 0 ;
47270   bool result;
47271
47272   arg1 = (Dali::Rect< int > *)jarg1;
47273   arg2 = (Dali::Rect< int > *)jarg2;
47274   if (!arg2) {
47275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47276     return 0;
47277   }
47278   {
47279     try {
47280       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47281     } catch (std::out_of_range& e) {
47282       {
47283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47284       };
47285     } catch (std::exception& e) {
47286       {
47287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47288       };
47289     } catch (Dali::DaliException e) {
47290       {
47291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47292       };
47293     } catch (...) {
47294       {
47295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47296       };
47297     }
47298   }
47299
47300   jresult = result;
47301   return jresult;
47302 }
47303
47304
47305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47306   unsigned int jresult ;
47307   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47308   Dali::Rect< int > *arg2 = 0 ;
47309   bool result;
47310
47311   arg1 = (Dali::Rect< int > *)jarg1;
47312   arg2 = (Dali::Rect< int > *)jarg2;
47313   if (!arg2) {
47314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47315     return 0;
47316   }
47317   {
47318     try {
47319       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47320     } catch (std::out_of_range& e) {
47321       {
47322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47323       };
47324     } catch (std::exception& e) {
47325       {
47326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47327       };
47328     } catch (Dali::DaliException e) {
47329       {
47330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47331       };
47332     } catch (...) {
47333       {
47334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47335       };
47336     }
47337   }
47338
47339   jresult = result;
47340   return jresult;
47341 }
47342
47343
47344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47345   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47346   int arg2 ;
47347
47348   arg1 = (Dali::Rect< int > *)jarg1;
47349   arg2 = (int)jarg2;
47350   if (arg1) (arg1)->x = arg2;
47351 }
47352
47353
47354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47355   int jresult ;
47356   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47357   int result;
47358
47359   arg1 = (Dali::Rect< int > *)jarg1;
47360   result = (int) ((arg1)->x);
47361   jresult = result;
47362   return jresult;
47363 }
47364
47365
47366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47367   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47368   int arg2 ;
47369
47370   arg1 = (Dali::Rect< int > *)jarg1;
47371   arg2 = (int)jarg2;
47372   if (arg1) (arg1)->left = arg2;
47373 }
47374
47375
47376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47377   int jresult ;
47378   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47379   int result;
47380
47381   arg1 = (Dali::Rect< int > *)jarg1;
47382   result = (int) ((arg1)->left);
47383   jresult = result;
47384   return jresult;
47385 }
47386
47387
47388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47389   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47390   int arg2 ;
47391
47392   arg1 = (Dali::Rect< int > *)jarg1;
47393   arg2 = (int)jarg2;
47394   if (arg1) (arg1)->y = arg2;
47395 }
47396
47397
47398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47399   int jresult ;
47400   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47401   int result;
47402
47403   arg1 = (Dali::Rect< int > *)jarg1;
47404   result = (int) ((arg1)->y);
47405   jresult = result;
47406   return jresult;
47407 }
47408
47409
47410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47411   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47412   int arg2 ;
47413
47414   arg1 = (Dali::Rect< int > *)jarg1;
47415   arg2 = (int)jarg2;
47416   if (arg1) (arg1)->right = arg2;
47417 }
47418
47419
47420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47421   int jresult ;
47422   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47423   int result;
47424
47425   arg1 = (Dali::Rect< int > *)jarg1;
47426   result = (int) ((arg1)->right);
47427   jresult = result;
47428   return jresult;
47429 }
47430
47431
47432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47433   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47434   int arg2 ;
47435
47436   arg1 = (Dali::Rect< int > *)jarg1;
47437   arg2 = (int)jarg2;
47438   if (arg1) (arg1)->width = arg2;
47439 }
47440
47441
47442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47443   int jresult ;
47444   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47445   int result;
47446
47447   arg1 = (Dali::Rect< int > *)jarg1;
47448   result = (int) ((arg1)->width);
47449   jresult = result;
47450   return jresult;
47451 }
47452
47453
47454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47455   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47456   int arg2 ;
47457
47458   arg1 = (Dali::Rect< int > *)jarg1;
47459   arg2 = (int)jarg2;
47460   if (arg1) (arg1)->bottom = arg2;
47461 }
47462
47463
47464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47465   int jresult ;
47466   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47467   int result;
47468
47469   arg1 = (Dali::Rect< int > *)jarg1;
47470   result = (int) ((arg1)->bottom);
47471   jresult = result;
47472   return jresult;
47473 }
47474
47475
47476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47477   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47478   int arg2 ;
47479
47480   arg1 = (Dali::Rect< int > *)jarg1;
47481   arg2 = (int)jarg2;
47482   if (arg1) (arg1)->height = arg2;
47483 }
47484
47485
47486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47487   int jresult ;
47488   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47489   int result;
47490
47491   arg1 = (Dali::Rect< int > *)jarg1;
47492   result = (int) ((arg1)->height);
47493   jresult = result;
47494   return jresult;
47495 }
47496
47497
47498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47499   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47500   int arg2 ;
47501
47502   arg1 = (Dali::Rect< int > *)jarg1;
47503   arg2 = (int)jarg2;
47504   if (arg1) (arg1)->top = arg2;
47505 }
47506
47507
47508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47509   int jresult ;
47510   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47511   int result;
47512
47513   arg1 = (Dali::Rect< int > *)jarg1;
47514   result = (int) ((arg1)->top);
47515   jresult = result;
47516   return jresult;
47517 }
47518
47519
47520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47521   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47522
47523   arg1 = (Dali::Rect< int > *)jarg1;
47524   {
47525     try {
47526       delete arg1;
47527     } catch (std::out_of_range& e) {
47528       {
47529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47530       };
47531     } catch (std::exception& e) {
47532       {
47533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47534       };
47535     } catch (Dali::DaliException e) {
47536       {
47537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47538       };
47539     } catch (...) {
47540       {
47541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47542       };
47543     }
47544   }
47545
47546 }
47547
47548
47549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47550   void * jresult ;
47551   Dali::Rect< float > *result = 0 ;
47552
47553   {
47554     try {
47555       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47556     } catch (std::out_of_range& e) {
47557       {
47558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47559       };
47560     } catch (std::exception& e) {
47561       {
47562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47563       };
47564     } catch (Dali::DaliException e) {
47565       {
47566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47567       };
47568     } catch (...) {
47569       {
47570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47571       };
47572     }
47573   }
47574
47575   jresult = (void *)result;
47576   return jresult;
47577 }
47578
47579
47580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47581   void * jresult ;
47582   float arg1 ;
47583   float arg2 ;
47584   float arg3 ;
47585   float arg4 ;
47586   Dali::Rect< float > *result = 0 ;
47587
47588   arg1 = (float)jarg1;
47589   arg2 = (float)jarg2;
47590   arg3 = (float)jarg4;
47591   arg4 = (float)jarg3;
47592   {
47593     try {
47594       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47595     } catch (std::out_of_range& e) {
47596       {
47597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47598       };
47599     } catch (std::exception& e) {
47600       {
47601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47602       };
47603     } catch (Dali::DaliException e) {
47604       {
47605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47606       };
47607     } catch (...) {
47608       {
47609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47610       };
47611     }
47612   }
47613
47614   jresult = (void *)result;
47615   return jresult;
47616 }
47617
47618
47619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47620   void * jresult ;
47621   Dali::Rect< float > *arg1 = 0 ;
47622   Dali::Rect< float > *result = 0 ;
47623
47624   arg1 = (Dali::Rect< float > *)jarg1;
47625   if (!arg1) {
47626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47627     return 0;
47628   }
47629   {
47630     try {
47631       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47632     } catch (std::out_of_range& e) {
47633       {
47634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47635       };
47636     } catch (std::exception& e) {
47637       {
47638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47639       };
47640     } catch (Dali::DaliException e) {
47641       {
47642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47643       };
47644     } catch (...) {
47645       {
47646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47647       };
47648     }
47649   }
47650
47651   jresult = (void *)result;
47652   return jresult;
47653 }
47654
47655
47656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47657   void * jresult ;
47658   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47659   Dali::Rect< float > *arg2 = 0 ;
47660   Dali::Rect< float > *result = 0 ;
47661
47662   arg1 = (Dali::Rect< float > *)jarg1;
47663   arg2 = (Dali::Rect< float > *)jarg2;
47664   if (!arg2) {
47665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47666     return 0;
47667   }
47668   {
47669     try {
47670       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47671     } catch (std::out_of_range& e) {
47672       {
47673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47674       };
47675     } catch (std::exception& e) {
47676       {
47677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47678       };
47679     } catch (Dali::DaliException e) {
47680       {
47681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47682       };
47683     } catch (...) {
47684       {
47685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47686       };
47687     }
47688   }
47689
47690   jresult = (void *)result;
47691   return jresult;
47692 }
47693
47694
47695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47696   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47697   float arg2 ;
47698   float arg3 ;
47699   float arg4 ;
47700   float arg5 ;
47701
47702   arg1 = (Dali::Rect< float > *)jarg1;
47703   arg2 = (float)jarg2;
47704   arg3 = (float)jarg3;
47705   arg4 = (float)jarg5;
47706   arg5 = (float)jarg4;
47707   {
47708     try {
47709       (arg1)->Set(arg2,arg3,arg4,arg5);
47710     } catch (std::out_of_range& e) {
47711       {
47712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47713       };
47714     } catch (std::exception& e) {
47715       {
47716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47717       };
47718     } catch (Dali::DaliException e) {
47719       {
47720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47721       };
47722     } catch (...) {
47723       {
47724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47725       };
47726     }
47727   }
47728
47729 }
47730
47731
47732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47733   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47734   float arg2 ;
47735
47736   arg1 = (Dali::Rect< float > *)jarg1;
47737   arg2 = (float)jarg2;
47738   if (arg1) (arg1)->left = arg2;
47739 }
47740
47741
47742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47743   float jresult ;
47744   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47745   float result;
47746
47747   arg1 = (Dali::Rect< float > *)jarg1;
47748   result = (float) ((arg1)->left);
47749   jresult = result;
47750   return jresult;
47751 }
47752
47753
47754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47755   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47756   float arg2 ;
47757
47758   arg1 = (Dali::Rect< float > *)jarg1;
47759   arg2 = (float)jarg2;
47760   if (arg1) (arg1)->left = arg2;
47761 }
47762
47763
47764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47765   float jresult ;
47766   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47767   float result;
47768
47769   arg1 = (Dali::Rect< float > *)jarg1;
47770   result = (float) ((arg1)->left);
47771   jresult = result;
47772   return jresult;
47773 }
47774
47775
47776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47777   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47778   float arg2 ;
47779
47780   arg1 = (Dali::Rect< float > *)jarg1;
47781   arg2 = (float)jarg2;
47782   if (arg1) (arg1)->right = arg2;
47783 }
47784
47785
47786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47787   float jresult ;
47788   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47789   float result;
47790
47791   arg1 = (Dali::Rect< float > *)jarg1;
47792   result = (float) ((arg1)->right);
47793   jresult = result;
47794   return jresult;
47795 }
47796
47797
47798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47799   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47800   float arg2 ;
47801
47802   arg1 = (Dali::Rect< float > *)jarg1;
47803   arg2 = (float)jarg2;
47804   if (arg1) (arg1)->right = arg2;
47805 }
47806
47807
47808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47809   float jresult ;
47810   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47811   float result;
47812
47813   arg1 = (Dali::Rect< float > *)jarg1;
47814   result = (float) ((arg1)->right);
47815   jresult = result;
47816   return jresult;
47817 }
47818
47819
47820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47821   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47822   float arg2 ;
47823
47824   arg1 = (Dali::Rect< float > *)jarg1;
47825   arg2 = (float)jarg2;
47826   if (arg1) (arg1)->bottom = arg2;
47827 }
47828
47829
47830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
47831   float jresult ;
47832   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47833   float result;
47834
47835   arg1 = (Dali::Rect< float > *)jarg1;
47836   result = (float) ((arg1)->bottom);
47837   jresult = result;
47838   return jresult;
47839 }
47840
47841
47842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
47843   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47844   float arg2 ;
47845
47846   arg1 = (Dali::Rect< float > *)jarg1;
47847   arg2 = (float)jarg2;
47848   if (arg1) (arg1)->top = arg2;
47849 }
47850
47851
47852 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
47853   float jresult ;
47854   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47855   float result;
47856
47857   arg1 = (Dali::Rect< float > *)jarg1;
47858   result = (float) ((arg1)->top);
47859   jresult = result;
47860   return jresult;
47861 }
47862
47863
47864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
47865   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47866
47867   arg1 = (Dali::Rect< float > *)jarg1;
47868   {
47869     try {
47870       delete arg1;
47871     } catch (std::out_of_range& e) {
47872       {
47873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47874       };
47875     } catch (std::exception& e) {
47876       {
47877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47878       };
47879     } catch (Dali::DaliException e) {
47880       {
47881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47882       };
47883     } catch (...) {
47884       {
47885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47886       };
47887     }
47888   }
47889
47890 }
47891
47892
47893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47894   int jresult ;
47895   int result;
47896
47897   result = (int)Dali::Vector< int >::BaseType;
47898   jresult = (int)result;
47899   return jresult;
47900 }
47901
47902
47903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47904   void * jresult ;
47905   Dali::Vector< int > *result = 0 ;
47906
47907   {
47908     try {
47909       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47910     } catch (std::out_of_range& e) {
47911       {
47912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47913       };
47914     } catch (std::exception& e) {
47915       {
47916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47917       };
47918     } catch (Dali::DaliException e) {
47919       {
47920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47921       };
47922     } catch (...) {
47923       {
47924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47925       };
47926     }
47927   }
47928
47929   jresult = (void *)result;
47930   return jresult;
47931 }
47932
47933
47934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47935   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47936
47937   arg1 = (Dali::Vector< int > *)jarg1;
47938   {
47939     try {
47940       delete arg1;
47941     } catch (std::out_of_range& e) {
47942       {
47943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47944       };
47945     } catch (std::exception& e) {
47946       {
47947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47948       };
47949     } catch (Dali::DaliException e) {
47950       {
47951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47952       };
47953     } catch (...) {
47954       {
47955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47956       };
47957     }
47958   }
47959
47960 }
47961
47962
47963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47964   void * jresult ;
47965   Dali::Vector< int > *arg1 = 0 ;
47966   Dali::Vector< int > *result = 0 ;
47967
47968   arg1 = (Dali::Vector< int > *)jarg1;
47969   if (!arg1) {
47970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47971     return 0;
47972   }
47973   {
47974     try {
47975       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47976     } catch (std::out_of_range& e) {
47977       {
47978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47979       };
47980     } catch (std::exception& e) {
47981       {
47982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47983       };
47984     } catch (Dali::DaliException e) {
47985       {
47986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47987       };
47988     } catch (...) {
47989       {
47990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47991       };
47992     }
47993   }
47994
47995   jresult = (void *)result;
47996   return jresult;
47997 }
47998
47999
48000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
48001   void * jresult ;
48002   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48003   Dali::Vector< int > *arg2 = 0 ;
48004   Dali::Vector< int > *result = 0 ;
48005
48006   arg1 = (Dali::Vector< int > *)jarg1;
48007   arg2 = (Dali::Vector< int > *)jarg2;
48008   if (!arg2) {
48009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48010     return 0;
48011   }
48012   {
48013     try {
48014       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
48015     } catch (std::out_of_range& e) {
48016       {
48017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48018       };
48019     } catch (std::exception& e) {
48020       {
48021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48022       };
48023     } catch (Dali::DaliException e) {
48024       {
48025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48026       };
48027     } catch (...) {
48028       {
48029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48030       };
48031     }
48032   }
48033
48034   jresult = (void *)result;
48035   return jresult;
48036 }
48037
48038
48039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
48040   void * jresult ;
48041   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48042   Dali::Vector< int >::Iterator result;
48043
48044   arg1 = (Dali::Vector< int > *)jarg1;
48045   {
48046     try {
48047       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
48048     } catch (std::out_of_range& e) {
48049       {
48050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48051       };
48052     } catch (std::exception& e) {
48053       {
48054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48055       };
48056     } catch (Dali::DaliException e) {
48057       {
48058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48059       };
48060     } catch (...) {
48061       {
48062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48063       };
48064     }
48065   }
48066
48067   jresult = (void *)result;
48068   return jresult;
48069 }
48070
48071
48072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
48073   void * jresult ;
48074   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48075   Dali::Vector< int >::Iterator result;
48076
48077   arg1 = (Dali::Vector< int > *)jarg1;
48078   {
48079     try {
48080       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
48081     } catch (std::out_of_range& e) {
48082       {
48083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48084       };
48085     } catch (std::exception& e) {
48086       {
48087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48088       };
48089     } catch (Dali::DaliException e) {
48090       {
48091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48092       };
48093     } catch (...) {
48094       {
48095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48096       };
48097     }
48098   }
48099
48100   jresult = (void *)result;
48101   return jresult;
48102 }
48103
48104
48105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48106   void * jresult ;
48107   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48108   Dali::Vector< int >::SizeType arg2 ;
48109   Dali::Vector< int >::ItemType *result = 0 ;
48110
48111   arg1 = (Dali::Vector< int > *)jarg1;
48112   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48113   {
48114     try {
48115       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
48116     } catch (std::out_of_range& e) {
48117       {
48118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48119       };
48120     } catch (std::exception& e) {
48121       {
48122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48123       };
48124     } catch (Dali::DaliException e) {
48125       {
48126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48127       };
48128     } catch (...) {
48129       {
48130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48131       };
48132     }
48133   }
48134
48135   jresult = (void *)result;
48136   return jresult;
48137 }
48138
48139
48140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
48141   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48142   Dali::Vector< int >::ItemType *arg2 = 0 ;
48143   Dali::Vector< int >::ItemType temp2 ;
48144
48145   arg1 = (Dali::Vector< int > *)jarg1;
48146   temp2 = (Dali::Vector< int >::ItemType)jarg2;
48147   arg2 = &temp2;
48148   {
48149     try {
48150       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
48151     } catch (std::out_of_range& e) {
48152       {
48153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48154       };
48155     } catch (std::exception& e) {
48156       {
48157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48158       };
48159     } catch (Dali::DaliException e) {
48160       {
48161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48162       };
48163     } catch (...) {
48164       {
48165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48166       };
48167     }
48168   }
48169
48170 }
48171
48172
48173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
48174   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48175   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48176   Dali::Vector< int >::ItemType *arg3 = 0 ;
48177   Dali::Vector< int >::ItemType temp3 ;
48178
48179   arg1 = (Dali::Vector< int > *)jarg1;
48180   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48181   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48182   arg3 = &temp3;
48183   {
48184     try {
48185       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48186     } catch (std::out_of_range& e) {
48187       {
48188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48189       };
48190     } catch (std::exception& e) {
48191       {
48192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48193       };
48194     } catch (Dali::DaliException e) {
48195       {
48196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48197       };
48198     } catch (...) {
48199       {
48200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48201       };
48202     }
48203   }
48204
48205 }
48206
48207
48208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48209   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48210   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48211   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48212   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
48213
48214   arg1 = (Dali::Vector< int > *)jarg1;
48215   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48216   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48217   arg4 = (Dali::Vector< int >::Iterator)jarg4;
48218   {
48219     try {
48220       (arg1)->Insert(arg2,arg3,arg4);
48221     } catch (std::out_of_range& e) {
48222       {
48223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48224       };
48225     } catch (std::exception& e) {
48226       {
48227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48228       };
48229     } catch (Dali::DaliException e) {
48230       {
48231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48232       };
48233     } catch (...) {
48234       {
48235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48236       };
48237     }
48238   }
48239
48240 }
48241
48242
48243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
48244   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48245   Dali::Vector< int >::SizeType arg2 ;
48246
48247   arg1 = (Dali::Vector< int > *)jarg1;
48248   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48249   {
48250     try {
48251       (arg1)->Reserve(arg2);
48252     } catch (std::out_of_range& e) {
48253       {
48254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48255       };
48256     } catch (std::exception& e) {
48257       {
48258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48259       };
48260     } catch (Dali::DaliException e) {
48261       {
48262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48263       };
48264     } catch (...) {
48265       {
48266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48267       };
48268     }
48269   }
48270
48271 }
48272
48273
48274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48275   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48276   Dali::Vector< int >::SizeType arg2 ;
48277
48278   arg1 = (Dali::Vector< int > *)jarg1;
48279   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48280   {
48281     try {
48282       (arg1)->Resize(arg2);
48283     } catch (std::out_of_range& e) {
48284       {
48285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48286       };
48287     } catch (std::exception& e) {
48288       {
48289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48290       };
48291     } catch (Dali::DaliException e) {
48292       {
48293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48294       };
48295     } catch (...) {
48296       {
48297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48298       };
48299     }
48300   }
48301
48302 }
48303
48304
48305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48306   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48307   Dali::Vector< int >::SizeType arg2 ;
48308   Dali::Vector< int >::ItemType *arg3 = 0 ;
48309   Dali::Vector< int >::ItemType temp3 ;
48310
48311   arg1 = (Dali::Vector< int > *)jarg1;
48312   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48313   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48314   arg3 = &temp3;
48315   {
48316     try {
48317       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48318     } catch (std::out_of_range& e) {
48319       {
48320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48321       };
48322     } catch (std::exception& e) {
48323       {
48324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48325       };
48326     } catch (Dali::DaliException e) {
48327       {
48328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48329       };
48330     } catch (...) {
48331       {
48332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48333       };
48334     }
48335   }
48336
48337 }
48338
48339
48340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48341   void * jresult ;
48342   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48343   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48344   Dali::Vector< int >::Iterator result;
48345
48346   arg1 = (Dali::Vector< int > *)jarg1;
48347   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48348   {
48349     try {
48350       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48351     } catch (std::out_of_range& e) {
48352       {
48353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48354       };
48355     } catch (std::exception& e) {
48356       {
48357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48358       };
48359     } catch (Dali::DaliException e) {
48360       {
48361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48362       };
48363     } catch (...) {
48364       {
48365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48366       };
48367     }
48368   }
48369
48370   jresult = (void *)result;
48371   return jresult;
48372 }
48373
48374
48375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48376   void * jresult ;
48377   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48378   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48379   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48380   Dali::Vector< int >::Iterator result;
48381
48382   arg1 = (Dali::Vector< int > *)jarg1;
48383   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48384   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48385   {
48386     try {
48387       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48388     } catch (std::out_of_range& e) {
48389       {
48390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48391       };
48392     } catch (std::exception& e) {
48393       {
48394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48395       };
48396     } catch (Dali::DaliException e) {
48397       {
48398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48399       };
48400     } catch (...) {
48401       {
48402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48403       };
48404     }
48405   }
48406
48407   jresult = (void *)result;
48408   return jresult;
48409 }
48410
48411
48412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48413   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48414   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48415
48416   arg1 = (Dali::Vector< int > *)jarg1;
48417   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48418   {
48419     try {
48420       (arg1)->Remove(arg2);
48421     } catch (std::out_of_range& e) {
48422       {
48423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48424       };
48425     } catch (std::exception& e) {
48426       {
48427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48428       };
48429     } catch (Dali::DaliException e) {
48430       {
48431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48432       };
48433     } catch (...) {
48434       {
48435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48436       };
48437     }
48438   }
48439
48440 }
48441
48442
48443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48444   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48445   Dali::Vector< int > *arg2 = 0 ;
48446
48447   arg1 = (Dali::Vector< int > *)jarg1;
48448   arg2 = (Dali::Vector< int > *)jarg2;
48449   if (!arg2) {
48450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48451     return ;
48452   }
48453   {
48454     try {
48455       (arg1)->Swap(*arg2);
48456     } catch (std::out_of_range& e) {
48457       {
48458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48459       };
48460     } catch (std::exception& e) {
48461       {
48462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48463       };
48464     } catch (Dali::DaliException e) {
48465       {
48466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48467       };
48468     } catch (...) {
48469       {
48470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48471       };
48472     }
48473   }
48474
48475 }
48476
48477
48478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48479   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48480
48481   arg1 = (Dali::Vector< int > *)jarg1;
48482   {
48483     try {
48484       (arg1)->Clear();
48485     } catch (std::out_of_range& e) {
48486       {
48487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48488       };
48489     } catch (std::exception& e) {
48490       {
48491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48492       };
48493     } catch (Dali::DaliException e) {
48494       {
48495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48496       };
48497     } catch (...) {
48498       {
48499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48500       };
48501     }
48502   }
48503
48504 }
48505
48506
48507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48508   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48509
48510   arg1 = (Dali::Vector< int > *)jarg1;
48511   {
48512     try {
48513       (arg1)->Release();
48514     } catch (std::out_of_range& e) {
48515       {
48516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48517       };
48518     } catch (std::exception& e) {
48519       {
48520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48521       };
48522     } catch (Dali::DaliException e) {
48523       {
48524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48525       };
48526     } catch (...) {
48527       {
48528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48529       };
48530     }
48531   }
48532
48533 }
48534
48535
48536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48537   int jresult ;
48538   int result;
48539
48540   result = (int)Dali::Vector< float >::BaseType;
48541   jresult = (int)result;
48542   return jresult;
48543 }
48544
48545
48546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48547   void * jresult ;
48548   Dali::Vector< float > *result = 0 ;
48549
48550   {
48551     try {
48552       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48553     } catch (std::out_of_range& e) {
48554       {
48555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48556       };
48557     } catch (std::exception& e) {
48558       {
48559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48560       };
48561     } catch (Dali::DaliException e) {
48562       {
48563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48564       };
48565     } catch (...) {
48566       {
48567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48568       };
48569     }
48570   }
48571
48572   jresult = (void *)result;
48573   return jresult;
48574 }
48575
48576
48577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48578   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48579
48580   arg1 = (Dali::Vector< float > *)jarg1;
48581   {
48582     try {
48583       delete arg1;
48584     } catch (std::out_of_range& e) {
48585       {
48586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48587       };
48588     } catch (std::exception& e) {
48589       {
48590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48591       };
48592     } catch (Dali::DaliException e) {
48593       {
48594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48595       };
48596     } catch (...) {
48597       {
48598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48599       };
48600     }
48601   }
48602
48603 }
48604
48605
48606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48607   void * jresult ;
48608   Dali::Vector< float > *arg1 = 0 ;
48609   Dali::Vector< float > *result = 0 ;
48610
48611   arg1 = (Dali::Vector< float > *)jarg1;
48612   if (!arg1) {
48613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48614     return 0;
48615   }
48616   {
48617     try {
48618       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48619     } catch (std::out_of_range& e) {
48620       {
48621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48622       };
48623     } catch (std::exception& e) {
48624       {
48625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48626       };
48627     } catch (Dali::DaliException e) {
48628       {
48629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48630       };
48631     } catch (...) {
48632       {
48633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48634       };
48635     }
48636   }
48637
48638   jresult = (void *)result;
48639   return jresult;
48640 }
48641
48642
48643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48644   void * jresult ;
48645   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48646   Dali::Vector< float > *arg2 = 0 ;
48647   Dali::Vector< float > *result = 0 ;
48648
48649   arg1 = (Dali::Vector< float > *)jarg1;
48650   arg2 = (Dali::Vector< float > *)jarg2;
48651   if (!arg2) {
48652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48653     return 0;
48654   }
48655   {
48656     try {
48657       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48658     } catch (std::out_of_range& e) {
48659       {
48660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48661       };
48662     } catch (std::exception& e) {
48663       {
48664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48665       };
48666     } catch (Dali::DaliException e) {
48667       {
48668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48669       };
48670     } catch (...) {
48671       {
48672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48673       };
48674     }
48675   }
48676
48677   jresult = (void *)result;
48678   return jresult;
48679 }
48680
48681
48682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48683   void * jresult ;
48684   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48685   Dali::Vector< float >::Iterator result;
48686
48687   arg1 = (Dali::Vector< float > *)jarg1;
48688   {
48689     try {
48690       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48691     } catch (std::out_of_range& e) {
48692       {
48693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48694       };
48695     } catch (std::exception& e) {
48696       {
48697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48698       };
48699     } catch (Dali::DaliException e) {
48700       {
48701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48702       };
48703     } catch (...) {
48704       {
48705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48706       };
48707     }
48708   }
48709
48710   jresult = (void *)result;
48711   return jresult;
48712 }
48713
48714
48715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48716   void * jresult ;
48717   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48718   Dali::Vector< float >::Iterator result;
48719
48720   arg1 = (Dali::Vector< float > *)jarg1;
48721   {
48722     try {
48723       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48724     } catch (std::out_of_range& e) {
48725       {
48726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48727       };
48728     } catch (std::exception& e) {
48729       {
48730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48731       };
48732     } catch (Dali::DaliException e) {
48733       {
48734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48735       };
48736     } catch (...) {
48737       {
48738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48739       };
48740     }
48741   }
48742
48743   jresult = (void *)result;
48744   return jresult;
48745 }
48746
48747
48748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48749   void * jresult ;
48750   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48751   Dali::Vector< float >::SizeType arg2 ;
48752   Dali::Vector< float >::ItemType *result = 0 ;
48753
48754   arg1 = (Dali::Vector< float > *)jarg1;
48755   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48756   {
48757     try {
48758       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48759     } catch (std::out_of_range& e) {
48760       {
48761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48762       };
48763     } catch (std::exception& e) {
48764       {
48765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48766       };
48767     } catch (Dali::DaliException e) {
48768       {
48769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48770       };
48771     } catch (...) {
48772       {
48773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48774       };
48775     }
48776   }
48777
48778   jresult = (void *)result;
48779   return jresult;
48780 }
48781
48782
48783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48784   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48785   Dali::Vector< float >::ItemType *arg2 = 0 ;
48786   Dali::Vector< float >::ItemType temp2 ;
48787
48788   arg1 = (Dali::Vector< float > *)jarg1;
48789   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48790   arg2 = &temp2;
48791   {
48792     try {
48793       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48794     } catch (std::out_of_range& e) {
48795       {
48796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48797       };
48798     } catch (std::exception& e) {
48799       {
48800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48801       };
48802     } catch (Dali::DaliException e) {
48803       {
48804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48805       };
48806     } catch (...) {
48807       {
48808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48809       };
48810     }
48811   }
48812
48813 }
48814
48815
48816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48817   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48818   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48819   Dali::Vector< float >::ItemType *arg3 = 0 ;
48820   Dali::Vector< float >::ItemType temp3 ;
48821
48822   arg1 = (Dali::Vector< float > *)jarg1;
48823   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48824   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48825   arg3 = &temp3;
48826   {
48827     try {
48828       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48829     } catch (std::out_of_range& e) {
48830       {
48831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48832       };
48833     } catch (std::exception& e) {
48834       {
48835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48836       };
48837     } catch (Dali::DaliException e) {
48838       {
48839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48840       };
48841     } catch (...) {
48842       {
48843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48844       };
48845     }
48846   }
48847
48848 }
48849
48850
48851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48852   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48853   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48854   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48855   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48856
48857   arg1 = (Dali::Vector< float > *)jarg1;
48858   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48859   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48860   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48861   {
48862     try {
48863       (arg1)->Insert(arg2,arg3,arg4);
48864     } catch (std::out_of_range& e) {
48865       {
48866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48867       };
48868     } catch (std::exception& e) {
48869       {
48870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48871       };
48872     } catch (Dali::DaliException e) {
48873       {
48874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48875       };
48876     } catch (...) {
48877       {
48878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48879       };
48880     }
48881   }
48882
48883 }
48884
48885
48886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48887   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48888   Dali::Vector< float >::SizeType arg2 ;
48889
48890   arg1 = (Dali::Vector< float > *)jarg1;
48891   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48892   {
48893     try {
48894       (arg1)->Reserve(arg2);
48895     } catch (std::out_of_range& e) {
48896       {
48897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48898       };
48899     } catch (std::exception& e) {
48900       {
48901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48902       };
48903     } catch (Dali::DaliException e) {
48904       {
48905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48906       };
48907     } catch (...) {
48908       {
48909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48910       };
48911     }
48912   }
48913
48914 }
48915
48916 //// ========================= end of part 2 =============================
48917
48918 //// ========================== start part 3 ===============================
48919
48920
48921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48922   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48923   Dali::Vector< float >::SizeType arg2 ;
48924
48925   arg1 = (Dali::Vector< float > *)jarg1;
48926   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48927   {
48928     try {
48929       (arg1)->Resize(arg2);
48930     } catch (std::out_of_range& e) {
48931       {
48932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48933       };
48934     } catch (std::exception& e) {
48935       {
48936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48937       };
48938     } catch (Dali::DaliException e) {
48939       {
48940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48941       };
48942     } catch (...) {
48943       {
48944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48945       };
48946     }
48947   }
48948
48949 }
48950
48951
48952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48953   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48954   Dali::Vector< float >::SizeType arg2 ;
48955   Dali::Vector< float >::ItemType *arg3 = 0 ;
48956   Dali::Vector< float >::ItemType temp3 ;
48957
48958   arg1 = (Dali::Vector< float > *)jarg1;
48959   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48960   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48961   arg3 = &temp3;
48962   {
48963     try {
48964       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48965     } catch (std::out_of_range& e) {
48966       {
48967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48968       };
48969     } catch (std::exception& e) {
48970       {
48971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48972       };
48973     } catch (Dali::DaliException e) {
48974       {
48975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48976       };
48977     } catch (...) {
48978       {
48979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48980       };
48981     }
48982   }
48983
48984 }
48985
48986
48987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48988   void * jresult ;
48989   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48990   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48991   Dali::Vector< float >::Iterator result;
48992
48993   arg1 = (Dali::Vector< float > *)jarg1;
48994   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48995   {
48996     try {
48997       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48998     } catch (std::out_of_range& e) {
48999       {
49000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49001       };
49002     } catch (std::exception& e) {
49003       {
49004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49005       };
49006     } catch (Dali::DaliException e) {
49007       {
49008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49009       };
49010     } catch (...) {
49011       {
49012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49013       };
49014     }
49015   }
49016
49017   jresult = (void *)result;
49018   return jresult;
49019 }
49020
49021
49022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49023   void * jresult ;
49024   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49025   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49026   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49027   Dali::Vector< float >::Iterator result;
49028
49029   arg1 = (Dali::Vector< float > *)jarg1;
49030   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49031   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49032   {
49033     try {
49034       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
49035     } catch (std::out_of_range& e) {
49036       {
49037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49038       };
49039     } catch (std::exception& e) {
49040       {
49041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49042       };
49043     } catch (Dali::DaliException e) {
49044       {
49045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49046       };
49047     } catch (...) {
49048       {
49049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49050       };
49051     }
49052   }
49053
49054   jresult = (void *)result;
49055   return jresult;
49056 }
49057
49058
49059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
49060   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49061   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49062
49063   arg1 = (Dali::Vector< float > *)jarg1;
49064   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49065   {
49066     try {
49067       (arg1)->Remove(arg2);
49068     } catch (std::out_of_range& e) {
49069       {
49070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49071       };
49072     } catch (std::exception& e) {
49073       {
49074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49075       };
49076     } catch (Dali::DaliException e) {
49077       {
49078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49079       };
49080     } catch (...) {
49081       {
49082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49083       };
49084     }
49085   }
49086
49087 }
49088
49089
49090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
49091   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49092   Dali::Vector< float > *arg2 = 0 ;
49093
49094   arg1 = (Dali::Vector< float > *)jarg1;
49095   arg2 = (Dali::Vector< float > *)jarg2;
49096   if (!arg2) {
49097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
49098     return ;
49099   }
49100   {
49101     try {
49102       (arg1)->Swap(*arg2);
49103     } catch (std::out_of_range& e) {
49104       {
49105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49106       };
49107     } catch (std::exception& e) {
49108       {
49109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49110       };
49111     } catch (Dali::DaliException e) {
49112       {
49113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49114       };
49115     } catch (...) {
49116       {
49117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49118       };
49119     }
49120   }
49121
49122 }
49123
49124
49125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
49126   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49127
49128   arg1 = (Dali::Vector< float > *)jarg1;
49129   {
49130     try {
49131       (arg1)->Clear();
49132     } catch (std::out_of_range& e) {
49133       {
49134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49135       };
49136     } catch (std::exception& e) {
49137       {
49138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49139       };
49140     } catch (Dali::DaliException e) {
49141       {
49142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49143       };
49144     } catch (...) {
49145       {
49146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49147       };
49148     }
49149   }
49150
49151 }
49152
49153
49154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
49155   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49156
49157   arg1 = (Dali::Vector< float > *)jarg1;
49158   {
49159     try {
49160       (arg1)->Release();
49161     } catch (std::out_of_range& e) {
49162       {
49163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49164       };
49165     } catch (std::exception& e) {
49166       {
49167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49168       };
49169     } catch (Dali::DaliException e) {
49170       {
49171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49172       };
49173     } catch (...) {
49174       {
49175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49176       };
49177     }
49178   }
49179
49180 }
49181
49182
49183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
49184   int jresult ;
49185   int result;
49186
49187   result = (int)Dali::Vector< unsigned char >::BaseType;
49188   jresult = (int)result;
49189   return jresult;
49190 }
49191
49192
49193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
49194   void * jresult ;
49195   Dali::Vector< unsigned char > *result = 0 ;
49196
49197   {
49198     try {
49199       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
49200     } catch (std::out_of_range& e) {
49201       {
49202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49203       };
49204     } catch (std::exception& e) {
49205       {
49206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49207       };
49208     } catch (Dali::DaliException e) {
49209       {
49210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49211       };
49212     } catch (...) {
49213       {
49214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49215       };
49216     }
49217   }
49218
49219   jresult = (void *)result;
49220   return jresult;
49221 }
49222
49223
49224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
49225   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49226
49227   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49228   {
49229     try {
49230       delete arg1;
49231     } catch (std::out_of_range& e) {
49232       {
49233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49234       };
49235     } catch (std::exception& e) {
49236       {
49237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49238       };
49239     } catch (Dali::DaliException e) {
49240       {
49241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49242       };
49243     } catch (...) {
49244       {
49245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49246       };
49247     }
49248   }
49249
49250 }
49251
49252
49253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
49254   void * jresult ;
49255   Dali::Vector< unsigned char > *arg1 = 0 ;
49256   Dali::Vector< unsigned char > *result = 0 ;
49257
49258   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49259   if (!arg1) {
49260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49261     return 0;
49262   }
49263   {
49264     try {
49265       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
49266     } catch (std::out_of_range& e) {
49267       {
49268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49269       };
49270     } catch (std::exception& e) {
49271       {
49272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49273       };
49274     } catch (Dali::DaliException e) {
49275       {
49276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49277       };
49278     } catch (...) {
49279       {
49280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49281       };
49282     }
49283   }
49284
49285   jresult = (void *)result;
49286   return jresult;
49287 }
49288
49289
49290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49291   void * jresult ;
49292   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49293   Dali::Vector< unsigned char > *arg2 = 0 ;
49294   Dali::Vector< unsigned char > *result = 0 ;
49295
49296   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49297   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49298   if (!arg2) {
49299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49300     return 0;
49301   }
49302   {
49303     try {
49304       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49305     } catch (std::out_of_range& e) {
49306       {
49307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49308       };
49309     } catch (std::exception& e) {
49310       {
49311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49312       };
49313     } catch (Dali::DaliException e) {
49314       {
49315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49316       };
49317     } catch (...) {
49318       {
49319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49320       };
49321     }
49322   }
49323
49324   jresult = (void *)result;
49325   return jresult;
49326 }
49327
49328
49329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49330   void * jresult ;
49331   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49332   Dali::Vector< unsigned char >::Iterator result;
49333
49334   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49335   {
49336     try {
49337       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49338     } catch (std::out_of_range& e) {
49339       {
49340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49341       };
49342     } catch (std::exception& e) {
49343       {
49344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49345       };
49346     } catch (Dali::DaliException e) {
49347       {
49348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49349       };
49350     } catch (...) {
49351       {
49352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49353       };
49354     }
49355   }
49356
49357   jresult = (void *)result;
49358   return jresult;
49359 }
49360
49361
49362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49363   void * jresult ;
49364   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49365   Dali::Vector< unsigned char >::Iterator result;
49366
49367   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49368   {
49369     try {
49370       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49371     } catch (std::out_of_range& e) {
49372       {
49373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49374       };
49375     } catch (std::exception& e) {
49376       {
49377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49378       };
49379     } catch (Dali::DaliException e) {
49380       {
49381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49382       };
49383     } catch (...) {
49384       {
49385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49386       };
49387     }
49388   }
49389
49390   jresult = (void *)result;
49391   return jresult;
49392 }
49393
49394
49395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49396   void * jresult ;
49397   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49398   Dali::Vector< unsigned char >::SizeType arg2 ;
49399   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49400
49401   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49402   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49403   {
49404     try {
49405       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49406     } catch (std::out_of_range& e) {
49407       {
49408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49409       };
49410     } catch (std::exception& e) {
49411       {
49412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49413       };
49414     } catch (Dali::DaliException e) {
49415       {
49416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49417       };
49418     } catch (...) {
49419       {
49420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49421       };
49422     }
49423   }
49424
49425   jresult = (void *)result;
49426   return jresult;
49427 }
49428
49429
49430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49431   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49432   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49433   Dali::Vector< unsigned char >::ItemType temp2 ;
49434
49435   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49436   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49437   arg2 = &temp2;
49438   {
49439     try {
49440       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49441     } catch (std::out_of_range& e) {
49442       {
49443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49444       };
49445     } catch (std::exception& e) {
49446       {
49447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49448       };
49449     } catch (Dali::DaliException e) {
49450       {
49451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49452       };
49453     } catch (...) {
49454       {
49455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49456       };
49457     }
49458   }
49459
49460 }
49461
49462
49463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49464   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49465   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49466   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49467   Dali::Vector< unsigned char >::ItemType temp3 ;
49468
49469   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49470   arg2 = jarg2;
49471   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49472   arg3 = &temp3;
49473   {
49474     try {
49475       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49476     } catch (std::out_of_range& e) {
49477       {
49478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49479       };
49480     } catch (std::exception& e) {
49481       {
49482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49483       };
49484     } catch (Dali::DaliException e) {
49485       {
49486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49487       };
49488     } catch (...) {
49489       {
49490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49491       };
49492     }
49493   }
49494
49495
49496
49497 }
49498
49499
49500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49501   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49502   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49503   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49504   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49505
49506   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49507   arg2 = jarg2;
49508   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49509   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49510   {
49511     try {
49512       (arg1)->Insert(arg2,arg3,arg4);
49513     } catch (std::out_of_range& e) {
49514       {
49515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49516       };
49517     } catch (std::exception& e) {
49518       {
49519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49520       };
49521     } catch (Dali::DaliException e) {
49522       {
49523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49524       };
49525     } catch (...) {
49526       {
49527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49528       };
49529     }
49530   }
49531
49532
49533
49534 }
49535
49536
49537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49538   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49539   Dali::Vector< unsigned char >::SizeType arg2 ;
49540
49541   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49542   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49543   {
49544     try {
49545       (arg1)->Reserve(arg2);
49546     } catch (std::out_of_range& e) {
49547       {
49548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49549       };
49550     } catch (std::exception& e) {
49551       {
49552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49553       };
49554     } catch (Dali::DaliException e) {
49555       {
49556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49557       };
49558     } catch (...) {
49559       {
49560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49561       };
49562     }
49563   }
49564
49565 }
49566
49567
49568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49569   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49570   Dali::Vector< unsigned char >::SizeType arg2 ;
49571
49572   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49573   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49574   {
49575     try {
49576       (arg1)->Resize(arg2);
49577     } catch (std::out_of_range& e) {
49578       {
49579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49580       };
49581     } catch (std::exception& e) {
49582       {
49583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49584       };
49585     } catch (Dali::DaliException e) {
49586       {
49587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49588       };
49589     } catch (...) {
49590       {
49591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49592       };
49593     }
49594   }
49595
49596 }
49597
49598
49599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49600   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49601   Dali::Vector< unsigned char >::SizeType arg2 ;
49602   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49603   Dali::Vector< unsigned char >::ItemType temp3 ;
49604
49605   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49606   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49607   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49608   arg3 = &temp3;
49609   {
49610     try {
49611       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49612     } catch (std::out_of_range& e) {
49613       {
49614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49615       };
49616     } catch (std::exception& e) {
49617       {
49618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49619       };
49620     } catch (Dali::DaliException e) {
49621       {
49622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49623       };
49624     } catch (...) {
49625       {
49626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49627       };
49628     }
49629   }
49630
49631 }
49632
49633
49634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49635   void * jresult ;
49636   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49637   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49638   Dali::Vector< unsigned char >::Iterator result;
49639
49640   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49641   arg2 = jarg2;
49642   {
49643     try {
49644       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49645     } catch (std::out_of_range& e) {
49646       {
49647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49648       };
49649     } catch (std::exception& e) {
49650       {
49651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49652       };
49653     } catch (Dali::DaliException e) {
49654       {
49655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49656       };
49657     } catch (...) {
49658       {
49659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49660       };
49661     }
49662   }
49663
49664   jresult = (void *)result;
49665
49666
49667   return jresult;
49668 }
49669
49670
49671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49672   void * jresult ;
49673   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49674   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49675   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49676   Dali::Vector< unsigned char >::Iterator result;
49677
49678   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49679   arg2 = jarg2;
49680   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49681   {
49682     try {
49683       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49684     } catch (std::out_of_range& e) {
49685       {
49686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49687       };
49688     } catch (std::exception& e) {
49689       {
49690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49691       };
49692     } catch (Dali::DaliException e) {
49693       {
49694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49695       };
49696     } catch (...) {
49697       {
49698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49699       };
49700     }
49701   }
49702
49703   jresult = (void *)result;
49704
49705
49706   return jresult;
49707 }
49708
49709
49710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49711   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49712   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49713
49714   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49715   arg2 = jarg2;
49716   {
49717     try {
49718       (arg1)->Remove(arg2);
49719     } catch (std::out_of_range& e) {
49720       {
49721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49722       };
49723     } catch (std::exception& e) {
49724       {
49725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49726       };
49727     } catch (Dali::DaliException e) {
49728       {
49729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49730       };
49731     } catch (...) {
49732       {
49733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49734       };
49735     }
49736   }
49737
49738
49739
49740 }
49741
49742
49743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49744   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49745   Dali::Vector< unsigned char > *arg2 = 0 ;
49746
49747   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49748   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49749   if (!arg2) {
49750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49751     return ;
49752   }
49753   {
49754     try {
49755       (arg1)->Swap(*arg2);
49756     } catch (std::out_of_range& e) {
49757       {
49758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49759       };
49760     } catch (std::exception& e) {
49761       {
49762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49763       };
49764     } catch (Dali::DaliException e) {
49765       {
49766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49767       };
49768     } catch (...) {
49769       {
49770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49771       };
49772     }
49773   }
49774
49775 }
49776
49777
49778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49779   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49780
49781   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49782   {
49783     try {
49784       (arg1)->Clear();
49785     } catch (std::out_of_range& e) {
49786       {
49787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49788       };
49789     } catch (std::exception& e) {
49790       {
49791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49792       };
49793     } catch (Dali::DaliException e) {
49794       {
49795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49796       };
49797     } catch (...) {
49798       {
49799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49800       };
49801     }
49802   }
49803
49804 }
49805
49806
49807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49808   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49809
49810   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49811   {
49812     try {
49813       (arg1)->Release();
49814     } catch (std::out_of_range& e) {
49815       {
49816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49817       };
49818     } catch (std::exception& e) {
49819       {
49820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49821       };
49822     } catch (Dali::DaliException e) {
49823       {
49824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49825       };
49826     } catch (...) {
49827       {
49828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49829       };
49830     }
49831   }
49832
49833 }
49834
49835
49836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49837   int jresult ;
49838   int result;
49839
49840   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49841   jresult = (int)result;
49842   return jresult;
49843 }
49844
49845
49846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49847   void * jresult ;
49848   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49849
49850   {
49851     try {
49852       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49853     } catch (std::out_of_range& e) {
49854       {
49855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49856       };
49857     } catch (std::exception& e) {
49858       {
49859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49860       };
49861     } catch (Dali::DaliException e) {
49862       {
49863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49864       };
49865     } catch (...) {
49866       {
49867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49868       };
49869     }
49870   }
49871
49872   jresult = (void *)result;
49873   return jresult;
49874 }
49875
49876
49877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49878   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49879
49880   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49881   {
49882     try {
49883       delete arg1;
49884     } catch (std::out_of_range& e) {
49885       {
49886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49887       };
49888     } catch (std::exception& e) {
49889       {
49890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49891       };
49892     } catch (Dali::DaliException e) {
49893       {
49894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49895       };
49896     } catch (...) {
49897       {
49898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49899       };
49900     }
49901   }
49902
49903 }
49904
49905
49906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49907   void * jresult ;
49908   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49909   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49910
49911   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49912   if (!arg1) {
49913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49914     return 0;
49915   }
49916   {
49917     try {
49918       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49919     } catch (std::out_of_range& e) {
49920       {
49921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49922       };
49923     } catch (std::exception& e) {
49924       {
49925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49926       };
49927     } catch (Dali::DaliException e) {
49928       {
49929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49930       };
49931     } catch (...) {
49932       {
49933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49934       };
49935     }
49936   }
49937
49938   jresult = (void *)result;
49939   return jresult;
49940 }
49941
49942
49943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49944   void * jresult ;
49945   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49946   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49947   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49948
49949   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49950   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49951   if (!arg2) {
49952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49953     return 0;
49954   }
49955   {
49956     try {
49957       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49958     } catch (std::out_of_range& e) {
49959       {
49960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49961       };
49962     } catch (std::exception& e) {
49963       {
49964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49965       };
49966     } catch (Dali::DaliException e) {
49967       {
49968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49969       };
49970     } catch (...) {
49971       {
49972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49973       };
49974     }
49975   }
49976
49977   jresult = (void *)result;
49978   return jresult;
49979 }
49980
49981
49982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49983   void * jresult ;
49984   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49985   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49986
49987   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49988   {
49989     try {
49990       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49991     } catch (std::out_of_range& e) {
49992       {
49993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49994       };
49995     } catch (std::exception& e) {
49996       {
49997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49998       };
49999     } catch (Dali::DaliException e) {
50000       {
50001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50002       };
50003     } catch (...) {
50004       {
50005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50006       };
50007     }
50008   }
50009
50010   jresult = (void *)result;
50011   return jresult;
50012 }
50013
50014
50015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
50016   void * jresult ;
50017   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50018   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50019
50020   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50021   {
50022     try {
50023       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
50024     } catch (std::out_of_range& e) {
50025       {
50026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50027       };
50028     } catch (std::exception& e) {
50029       {
50030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50031       };
50032     } catch (Dali::DaliException e) {
50033       {
50034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50035       };
50036     } catch (...) {
50037       {
50038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50039       };
50040     }
50041   }
50042
50043   jresult = (void *)result;
50044   return jresult;
50045 }
50046
50047
50048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50049   void * jresult ;
50050   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50051   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50052   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
50053
50054   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50055   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50056   {
50057     try {
50058       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
50059     } catch (std::out_of_range& e) {
50060       {
50061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50062       };
50063     } catch (std::exception& e) {
50064       {
50065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50066       };
50067     } catch (Dali::DaliException e) {
50068       {
50069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50070       };
50071     } catch (...) {
50072       {
50073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50074       };
50075     }
50076   }
50077
50078   jresult = (void *)result;
50079   return jresult;
50080 }
50081
50082
50083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
50084   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50085   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
50086
50087   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50088   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
50089   if (!arg2) {
50090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50091     return ;
50092   }
50093   {
50094     try {
50095       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
50096     } catch (std::out_of_range& e) {
50097       {
50098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50099       };
50100     } catch (std::exception& e) {
50101       {
50102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50103       };
50104     } catch (Dali::DaliException e) {
50105       {
50106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50107       };
50108     } catch (...) {
50109       {
50110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50111       };
50112     }
50113   }
50114
50115 }
50116
50117
50118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
50119   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50120   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50121   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50122
50123   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50124   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50125   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50126   if (!arg3) {
50127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50128     return ;
50129   }
50130   {
50131     try {
50132       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50133     } catch (std::out_of_range& e) {
50134       {
50135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50136       };
50137     } catch (std::exception& e) {
50138       {
50139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50140       };
50141     } catch (Dali::DaliException e) {
50142       {
50143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50144       };
50145     } catch (...) {
50146       {
50147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50148       };
50149     }
50150   }
50151
50152 }
50153
50154
50155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
50156   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50157   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50158   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50159   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50160
50161   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50162   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50163   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50164   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
50165   {
50166     try {
50167       (arg1)->Insert(arg2,arg3,arg4);
50168     } catch (std::out_of_range& e) {
50169       {
50170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50171       };
50172     } catch (std::exception& e) {
50173       {
50174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50175       };
50176     } catch (Dali::DaliException e) {
50177       {
50178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50179       };
50180     } catch (...) {
50181       {
50182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50183       };
50184     }
50185   }
50186
50187 }
50188
50189
50190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
50191   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50192   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50193
50194   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50195   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50196   {
50197     try {
50198       (arg1)->Reserve(arg2);
50199     } catch (std::out_of_range& e) {
50200       {
50201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50202       };
50203     } catch (std::exception& e) {
50204       {
50205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50206       };
50207     } catch (Dali::DaliException e) {
50208       {
50209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50210       };
50211     } catch (...) {
50212       {
50213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50214       };
50215     }
50216   }
50217
50218 }
50219
50220
50221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50222   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50223   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50224
50225   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50226   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50227   {
50228     try {
50229       (arg1)->Resize(arg2);
50230     } catch (std::out_of_range& e) {
50231       {
50232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50233       };
50234     } catch (std::exception& e) {
50235       {
50236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50237       };
50238     } catch (Dali::DaliException e) {
50239       {
50240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50241       };
50242     } catch (...) {
50243       {
50244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50245       };
50246     }
50247   }
50248
50249 }
50250
50251
50252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
50253   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50254   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50255   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50256
50257   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50258   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50259   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50260   if (!arg3) {
50261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50262     return ;
50263   }
50264   {
50265     try {
50266       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50267     } catch (std::out_of_range& e) {
50268       {
50269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50270       };
50271     } catch (std::exception& e) {
50272       {
50273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50274       };
50275     } catch (Dali::DaliException e) {
50276       {
50277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50278       };
50279     } catch (...) {
50280       {
50281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50282       };
50283     }
50284   }
50285
50286 }
50287
50288
50289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50290   void * jresult ;
50291   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50292   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50293   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50294
50295   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50296   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50297   {
50298     try {
50299       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50300     } catch (std::out_of_range& e) {
50301       {
50302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50303       };
50304     } catch (std::exception& e) {
50305       {
50306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50307       };
50308     } catch (Dali::DaliException e) {
50309       {
50310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50311       };
50312     } catch (...) {
50313       {
50314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50315       };
50316     }
50317   }
50318
50319   jresult = (void *)result;
50320   return jresult;
50321 }
50322
50323
50324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50325   void * jresult ;
50326   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50327   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50328   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50329   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50330
50331   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50332   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50333   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50334   {
50335     try {
50336       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50337     } catch (std::out_of_range& e) {
50338       {
50339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50340       };
50341     } catch (std::exception& e) {
50342       {
50343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50344       };
50345     } catch (Dali::DaliException e) {
50346       {
50347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50348       };
50349     } catch (...) {
50350       {
50351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50352       };
50353     }
50354   }
50355
50356   jresult = (void *)result;
50357   return jresult;
50358 }
50359
50360
50361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50362   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50363   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50364
50365   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50366   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50367   {
50368     try {
50369       (arg1)->Remove(arg2);
50370     } catch (std::out_of_range& e) {
50371       {
50372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50373       };
50374     } catch (std::exception& e) {
50375       {
50376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50377       };
50378     } catch (Dali::DaliException e) {
50379       {
50380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50381       };
50382     } catch (...) {
50383       {
50384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50385       };
50386     }
50387   }
50388
50389 }
50390
50391
50392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50393   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50394   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50395
50396   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50397   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50398   if (!arg2) {
50399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50400     return ;
50401   }
50402   {
50403     try {
50404       (arg1)->Swap(*arg2);
50405     } catch (std::out_of_range& e) {
50406       {
50407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50408       };
50409     } catch (std::exception& e) {
50410       {
50411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50412       };
50413     } catch (Dali::DaliException e) {
50414       {
50415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50416       };
50417     } catch (...) {
50418       {
50419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50420       };
50421     }
50422   }
50423
50424 }
50425
50426
50427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50428   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50429
50430   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50431   {
50432     try {
50433       (arg1)->Clear();
50434     } catch (std::out_of_range& e) {
50435       {
50436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50437       };
50438     } catch (std::exception& e) {
50439       {
50440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50441       };
50442     } catch (Dali::DaliException e) {
50443       {
50444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50445       };
50446     } catch (...) {
50447       {
50448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50449       };
50450     }
50451   }
50452
50453 }
50454
50455
50456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50457   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50458
50459   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50460   {
50461     try {
50462       (arg1)->Release();
50463     } catch (std::out_of_range& e) {
50464       {
50465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50466       };
50467     } catch (std::exception& e) {
50468       {
50469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50470       };
50471     } catch (Dali::DaliException e) {
50472       {
50473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50474       };
50475     } catch (...) {
50476       {
50477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50478       };
50479     }
50480   }
50481
50482 }
50483
50484
50485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50486   void * jresult ;
50487   Dali::Signal< void () > *result = 0 ;
50488
50489   {
50490     try {
50491       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50492     } catch (std::out_of_range& e) {
50493       {
50494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50495       };
50496     } catch (std::exception& e) {
50497       {
50498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50499       };
50500     } catch (Dali::DaliException e) {
50501       {
50502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50503       };
50504     } catch (...) {
50505       {
50506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50507       };
50508     }
50509   }
50510
50511   jresult = (void *)result;
50512   return jresult;
50513 }
50514
50515
50516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50517   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50518
50519   arg1 = (Dali::Signal< void () > *)jarg1;
50520   {
50521     try {
50522       delete arg1;
50523     } catch (std::out_of_range& e) {
50524       {
50525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50526       };
50527     } catch (std::exception& e) {
50528       {
50529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50530       };
50531     } catch (Dali::DaliException e) {
50532       {
50533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50534       };
50535     } catch (...) {
50536       {
50537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50538       };
50539     }
50540   }
50541
50542 }
50543
50544
50545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50546   unsigned int jresult ;
50547   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50548   bool result;
50549
50550   arg1 = (Dali::Signal< void () > *)jarg1;
50551   {
50552     try {
50553       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50554     } catch (std::out_of_range& e) {
50555       {
50556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50557       };
50558     } catch (std::exception& e) {
50559       {
50560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50561       };
50562     } catch (Dali::DaliException e) {
50563       {
50564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50565       };
50566     } catch (...) {
50567       {
50568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50569       };
50570     }
50571   }
50572
50573   jresult = result;
50574   return jresult;
50575 }
50576
50577
50578 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50579   unsigned long jresult ;
50580   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50581   std::size_t result;
50582
50583   arg1 = (Dali::Signal< void () > *)jarg1;
50584   {
50585     try {
50586       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50587     } catch (std::out_of_range& e) {
50588       {
50589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50590       };
50591     } catch (std::exception& e) {
50592       {
50593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50594       };
50595     } catch (Dali::DaliException e) {
50596       {
50597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50598       };
50599     } catch (...) {
50600       {
50601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50602       };
50603     }
50604   }
50605
50606   jresult = (unsigned long)result;
50607   return jresult;
50608 }
50609
50610
50611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50612   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50613   void (*arg2)() = (void (*)()) 0 ;
50614
50615   arg1 = (Dali::Signal< void () > *)jarg1;
50616   arg2 = (void (*)())jarg2;
50617   {
50618     try {
50619       (arg1)->Connect(arg2);
50620     } catch (std::out_of_range& e) {
50621       {
50622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50623       };
50624     } catch (std::exception& e) {
50625       {
50626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50627       };
50628     } catch (Dali::DaliException e) {
50629       {
50630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50631       };
50632     } catch (...) {
50633       {
50634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50635       };
50636     }
50637   }
50638
50639 }
50640
50641
50642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50643   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50644   void (*arg2)() = (void (*)()) 0 ;
50645
50646   arg1 = (Dali::Signal< void () > *)jarg1;
50647   arg2 = (void (*)())jarg2;
50648   {
50649     try {
50650       (arg1)->Disconnect(arg2);
50651     } catch (std::out_of_range& e) {
50652       {
50653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50654       };
50655     } catch (std::exception& e) {
50656       {
50657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50658       };
50659     } catch (Dali::DaliException e) {
50660       {
50661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50662       };
50663     } catch (...) {
50664       {
50665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50666       };
50667     }
50668   }
50669
50670 }
50671
50672
50673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50674   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50675   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50676   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50677
50678   arg1 = (Dali::Signal< void () > *)jarg1;
50679   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50680   arg3 = (Dali::FunctorDelegate *)jarg3;
50681   {
50682     try {
50683       (arg1)->Connect(arg2,arg3);
50684     } catch (std::out_of_range& e) {
50685       {
50686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50687       };
50688     } catch (std::exception& e) {
50689       {
50690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50691       };
50692     } catch (Dali::DaliException e) {
50693       {
50694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50695       };
50696     } catch (...) {
50697       {
50698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50699       };
50700     }
50701   }
50702
50703 }
50704
50705
50706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50707   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50708
50709   arg1 = (Dali::Signal< void () > *)jarg1;
50710   {
50711     try {
50712       (arg1)->Emit();
50713     } catch (std::out_of_range& e) {
50714       {
50715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50716       };
50717     } catch (std::exception& e) {
50718       {
50719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50720       };
50721     } catch (Dali::DaliException e) {
50722       {
50723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50724       };
50725     } catch (...) {
50726       {
50727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50728       };
50729     }
50730   }
50731
50732 }
50733
50734
50735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50736   unsigned int jresult ;
50737   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50738   bool result;
50739
50740   arg1 = (Dali::Signal< void (float) > *)jarg1;
50741   {
50742     try {
50743       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50744     } catch (std::out_of_range& e) {
50745       {
50746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50747       };
50748     } catch (std::exception& e) {
50749       {
50750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50751       };
50752     } catch (Dali::DaliException e) {
50753       {
50754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50755       };
50756     } catch (...) {
50757       {
50758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50759       };
50760     }
50761   }
50762
50763   jresult = result;
50764   return jresult;
50765 }
50766
50767
50768 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50769   unsigned long jresult ;
50770   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50771   std::size_t result;
50772
50773   arg1 = (Dali::Signal< void (float) > *)jarg1;
50774   {
50775     try {
50776       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50777     } catch (std::out_of_range& e) {
50778       {
50779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50780       };
50781     } catch (std::exception& e) {
50782       {
50783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50784       };
50785     } catch (Dali::DaliException e) {
50786       {
50787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50788       };
50789     } catch (...) {
50790       {
50791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50792       };
50793     }
50794   }
50795
50796   jresult = (unsigned long)result;
50797   return jresult;
50798 }
50799
50800
50801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50802   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50803   void (*arg2)(float) = (void (*)(float)) 0 ;
50804
50805   arg1 = (Dali::Signal< void (float) > *)jarg1;
50806   arg2 = (void (*)(float))jarg2;
50807   {
50808     try {
50809       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50810     } catch (std::out_of_range& e) {
50811       {
50812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50813       };
50814     } catch (std::exception& e) {
50815       {
50816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50817       };
50818     } catch (Dali::DaliException e) {
50819       {
50820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50821       };
50822     } catch (...) {
50823       {
50824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50825       };
50826     }
50827   }
50828
50829 }
50830
50831
50832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50833   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50834   void (*arg2)(float) = (void (*)(float)) 0 ;
50835
50836   arg1 = (Dali::Signal< void (float) > *)jarg1;
50837   arg2 = (void (*)(float))jarg2;
50838   {
50839     try {
50840       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50841     } catch (std::out_of_range& e) {
50842       {
50843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50844       };
50845     } catch (std::exception& e) {
50846       {
50847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50848       };
50849     } catch (Dali::DaliException e) {
50850       {
50851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50852       };
50853     } catch (...) {
50854       {
50855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50856       };
50857     }
50858   }
50859
50860 }
50861
50862
50863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50864   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50865   float arg2 ;
50866
50867   arg1 = (Dali::Signal< void (float) > *)jarg1;
50868   arg2 = (float)jarg2;
50869   {
50870     try {
50871       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50872     } catch (std::out_of_range& e) {
50873       {
50874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50875       };
50876     } catch (std::exception& e) {
50877       {
50878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50879       };
50880     } catch (Dali::DaliException e) {
50881       {
50882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50883       };
50884     } catch (...) {
50885       {
50886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50887       };
50888     }
50889   }
50890
50891 }
50892
50893
50894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50895   void * jresult ;
50896   Dali::Signal< void (float) > *result = 0 ;
50897
50898   {
50899     try {
50900       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50901     } catch (std::out_of_range& e) {
50902       {
50903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50904       };
50905     } catch (std::exception& e) {
50906       {
50907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50908       };
50909     } catch (Dali::DaliException e) {
50910       {
50911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50912       };
50913     } catch (...) {
50914       {
50915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50916       };
50917     }
50918   }
50919
50920   jresult = (void *)result;
50921   return jresult;
50922 }
50923
50924
50925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50926   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50927
50928   arg1 = (Dali::Signal< void (float) > *)jarg1;
50929   {
50930     try {
50931       delete arg1;
50932     } catch (std::out_of_range& e) {
50933       {
50934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50935       };
50936     } catch (std::exception& e) {
50937       {
50938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50939       };
50940     } catch (Dali::DaliException e) {
50941       {
50942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50943       };
50944     } catch (...) {
50945       {
50946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50947       };
50948     }
50949   }
50950
50951 }
50952
50953
50954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50955   unsigned int jresult ;
50956   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50957   bool result;
50958
50959   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50960   {
50961     try {
50962       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50963     } catch (std::out_of_range& e) {
50964       {
50965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50966       };
50967     } catch (std::exception& e) {
50968       {
50969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50970       };
50971     } catch (Dali::DaliException e) {
50972       {
50973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50974       };
50975     } catch (...) {
50976       {
50977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50978       };
50979     }
50980   }
50981
50982   jresult = result;
50983   return jresult;
50984 }
50985
50986
50987 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50988   unsigned long jresult ;
50989   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50990   std::size_t result;
50991
50992   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50993   {
50994     try {
50995       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50996     } catch (std::out_of_range& e) {
50997       {
50998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50999       };
51000     } catch (std::exception& e) {
51001       {
51002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51003       };
51004     } catch (Dali::DaliException e) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51007       };
51008     } catch (...) {
51009       {
51010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51011       };
51012     }
51013   }
51014
51015   jresult = (unsigned long)result;
51016   return jresult;
51017 }
51018
51019
51020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
51021   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51022   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51023
51024   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51025   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51026   {
51027     try {
51028       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
51029     } catch (std::out_of_range& e) {
51030       {
51031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51032       };
51033     } catch (std::exception& e) {
51034       {
51035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51036       };
51037     } catch (Dali::DaliException e) {
51038       {
51039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51040       };
51041     } catch (...) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51044       };
51045     }
51046   }
51047
51048 }
51049
51050
51051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
51052   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51053   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51054
51055   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51056   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51057   {
51058     try {
51059       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
51060     } catch (std::out_of_range& e) {
51061       {
51062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51063       };
51064     } catch (std::exception& e) {
51065       {
51066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51067       };
51068     } catch (Dali::DaliException e) {
51069       {
51070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51071       };
51072     } catch (...) {
51073       {
51074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51075       };
51076     }
51077   }
51078
51079 }
51080
51081
51082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
51083   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51084   Dali::BaseHandle arg2 ;
51085   Dali::BaseHandle *argp2 ;
51086
51087   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51088   argp2 = (Dali::BaseHandle *)jarg2;
51089   if (!argp2) {
51090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51091     return ;
51092   }
51093   arg2 = *argp2;
51094   {
51095     try {
51096       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
51097     } catch (std::out_of_range& e) {
51098       {
51099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51100       };
51101     } catch (std::exception& e) {
51102       {
51103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51104       };
51105     } catch (Dali::DaliException e) {
51106       {
51107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51108       };
51109     } catch (...) {
51110       {
51111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51112       };
51113     }
51114   }
51115
51116 }
51117
51118
51119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
51120   void * jresult ;
51121   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
51122
51123   {
51124     try {
51125       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
51126     } catch (std::out_of_range& e) {
51127       {
51128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51129       };
51130     } catch (std::exception& e) {
51131       {
51132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51133       };
51134     } catch (Dali::DaliException e) {
51135       {
51136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51137       };
51138     } catch (...) {
51139       {
51140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51141       };
51142     }
51143   }
51144
51145   jresult = (void *)result;
51146   return jresult;
51147 }
51148
51149
51150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
51151   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51152
51153   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51154   {
51155     try {
51156       delete arg1;
51157     } catch (std::out_of_range& e) {
51158       {
51159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51160       };
51161     } catch (std::exception& e) {
51162       {
51163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51164       };
51165     } catch (Dali::DaliException e) {
51166       {
51167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51168       };
51169     } catch (...) {
51170       {
51171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51172       };
51173     }
51174   }
51175
51176 }
51177
51178
51179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
51180   unsigned int jresult ;
51181   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51182   bool result;
51183
51184   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51185   {
51186     try {
51187       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51188     } catch (std::out_of_range& e) {
51189       {
51190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51191       };
51192     } catch (std::exception& e) {
51193       {
51194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51195       };
51196     } catch (Dali::DaliException e) {
51197       {
51198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51199       };
51200     } catch (...) {
51201       {
51202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51203       };
51204     }
51205   }
51206
51207   jresult = result;
51208   return jresult;
51209 }
51210
51211
51212 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
51213   unsigned long jresult ;
51214   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51215   std::size_t result;
51216
51217   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51218   {
51219     try {
51220       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51221     } catch (std::out_of_range& e) {
51222       {
51223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51224       };
51225     } catch (std::exception& e) {
51226       {
51227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51228       };
51229     } catch (Dali::DaliException e) {
51230       {
51231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51232       };
51233     } catch (...) {
51234       {
51235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51236       };
51237     }
51238   }
51239
51240   jresult = (unsigned long)result;
51241   return jresult;
51242 }
51243
51244
51245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
51246   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51247   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51248
51249   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51250   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51251   {
51252     try {
51253       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
51254     } catch (std::out_of_range& e) {
51255       {
51256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51257       };
51258     } catch (std::exception& e) {
51259       {
51260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51261       };
51262     } catch (Dali::DaliException e) {
51263       {
51264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51265       };
51266     } catch (...) {
51267       {
51268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51269       };
51270     }
51271   }
51272
51273 }
51274
51275
51276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51277   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51278   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51279
51280   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51281   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51282   {
51283     try {
51284       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51285     } catch (std::out_of_range& e) {
51286       {
51287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51288       };
51289     } catch (std::exception& e) {
51290       {
51291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51292       };
51293     } catch (Dali::DaliException e) {
51294       {
51295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51296       };
51297     } catch (...) {
51298       {
51299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51300       };
51301     }
51302   }
51303
51304 }
51305
51306
51307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51308   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51309   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51310
51311   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51312   arg2 = (Dali::RefObject *)jarg2;
51313   {
51314     try {
51315       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51316     } catch (std::out_of_range& e) {
51317       {
51318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51319       };
51320     } catch (std::exception& e) {
51321       {
51322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51323       };
51324     } catch (Dali::DaliException e) {
51325       {
51326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51327       };
51328     } catch (...) {
51329       {
51330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51331       };
51332     }
51333   }
51334
51335 }
51336
51337
51338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51339   void * jresult ;
51340   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51341
51342   {
51343     try {
51344       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51345     } catch (std::out_of_range& e) {
51346       {
51347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51348       };
51349     } catch (std::exception& e) {
51350       {
51351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51352       };
51353     } catch (Dali::DaliException e) {
51354       {
51355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51356       };
51357     } catch (...) {
51358       {
51359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51360       };
51361     }
51362   }
51363
51364   jresult = (void *)result;
51365   return jresult;
51366 }
51367
51368
51369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51370   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51371
51372   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51373   {
51374     try {
51375       delete arg1;
51376     } catch (std::out_of_range& e) {
51377       {
51378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51379       };
51380     } catch (std::exception& e) {
51381       {
51382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51383       };
51384     } catch (Dali::DaliException e) {
51385       {
51386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51387       };
51388     } catch (...) {
51389       {
51390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51391       };
51392     }
51393   }
51394
51395 }
51396
51397
51398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51399   unsigned int jresult ;
51400   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51401   bool result;
51402
51403   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51404   {
51405     try {
51406       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51407     } catch (std::out_of_range& e) {
51408       {
51409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51410       };
51411     } catch (std::exception& e) {
51412       {
51413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51414       };
51415     } catch (Dali::DaliException e) {
51416       {
51417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51418       };
51419     } catch (...) {
51420       {
51421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51422       };
51423     }
51424   }
51425
51426   jresult = result;
51427   return jresult;
51428 }
51429
51430
51431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51432   unsigned long jresult ;
51433   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51434   std::size_t result;
51435
51436   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51437   {
51438     try {
51439       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51440     } catch (std::out_of_range& e) {
51441       {
51442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51443       };
51444     } catch (std::exception& e) {
51445       {
51446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51447       };
51448     } catch (Dali::DaliException e) {
51449       {
51450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51451       };
51452     } catch (...) {
51453       {
51454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51455       };
51456     }
51457   }
51458
51459   jresult = (unsigned long)result;
51460   return jresult;
51461 }
51462
51463
51464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51465   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51466   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51467
51468   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51469   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51470   {
51471     try {
51472       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51473     } catch (std::out_of_range& e) {
51474       {
51475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51476       };
51477     } catch (std::exception& e) {
51478       {
51479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51480       };
51481     } catch (Dali::DaliException e) {
51482       {
51483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51484       };
51485     } catch (...) {
51486       {
51487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51488       };
51489     }
51490   }
51491
51492 }
51493
51494
51495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51496   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51497   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51498
51499   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51500   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51501   {
51502     try {
51503       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51504     } catch (std::out_of_range& e) {
51505       {
51506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51507       };
51508     } catch (std::exception& e) {
51509       {
51510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51511       };
51512     } catch (Dali::DaliException e) {
51513       {
51514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51515       };
51516     } catch (...) {
51517       {
51518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51519       };
51520     }
51521   }
51522
51523 }
51524
51525
51526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51527   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51528   Dali::PropertyNotification *arg2 = 0 ;
51529
51530   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51531   arg2 = (Dali::PropertyNotification *)jarg2;
51532   if (!arg2) {
51533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51534     return ;
51535   }
51536   {
51537     try {
51538       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51539     } catch (std::out_of_range& e) {
51540       {
51541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51542       };
51543     } catch (std::exception& e) {
51544       {
51545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51546       };
51547     } catch (Dali::DaliException e) {
51548       {
51549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51550       };
51551     } catch (...) {
51552       {
51553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51554       };
51555     }
51556   }
51557
51558 }
51559
51560
51561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51562   void * jresult ;
51563   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51564
51565   {
51566     try {
51567       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51568     } catch (std::out_of_range& e) {
51569       {
51570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51571       };
51572     } catch (std::exception& e) {
51573       {
51574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51575       };
51576     } catch (Dali::DaliException e) {
51577       {
51578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51579       };
51580     } catch (...) {
51581       {
51582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51583       };
51584     }
51585   }
51586
51587   jresult = (void *)result;
51588   return jresult;
51589 }
51590
51591
51592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51593   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51594
51595   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51596   {
51597     try {
51598       delete arg1;
51599     } catch (std::out_of_range& e) {
51600       {
51601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51602       };
51603     } catch (std::exception& e) {
51604       {
51605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51606       };
51607     } catch (Dali::DaliException e) {
51608       {
51609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51610       };
51611     } catch (...) {
51612       {
51613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51614       };
51615     }
51616   }
51617
51618 }
51619
51620
51621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51622   void * jresult ;
51623   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51624
51625   {
51626     try {
51627       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51628     } catch (std::out_of_range& e) {
51629       {
51630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51631       };
51632     } catch (std::exception& e) {
51633       {
51634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51635       };
51636     } catch (Dali::DaliException e) {
51637       {
51638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51639       };
51640     } catch (...) {
51641       {
51642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51643       };
51644     }
51645   }
51646
51647   jresult = (void *)result;
51648   return jresult;
51649 }
51650
51651
51652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51653   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51654
51655   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51656   {
51657     try {
51658       delete arg1;
51659     } catch (std::out_of_range& e) {
51660       {
51661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51662       };
51663     } catch (std::exception& e) {
51664       {
51665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51666       };
51667     } catch (Dali::DaliException e) {
51668       {
51669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51670       };
51671     } catch (...) {
51672       {
51673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51674       };
51675     }
51676   }
51677
51678 }
51679
51680
51681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51682   unsigned int jresult ;
51683   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51684   bool result;
51685
51686   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51687   {
51688     try {
51689       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);
51690     } catch (std::out_of_range& e) {
51691       {
51692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51693       };
51694     } catch (std::exception& e) {
51695       {
51696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51697       };
51698     } catch (Dali::DaliException e) {
51699       {
51700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51701       };
51702     } catch (...) {
51703       {
51704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51705       };
51706     }
51707   }
51708
51709   jresult = result;
51710   return jresult;
51711 }
51712
51713
51714 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51715   unsigned long jresult ;
51716   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51717   std::size_t result;
51718
51719   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51720   {
51721     try {
51722       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);
51723     } catch (std::out_of_range& e) {
51724       {
51725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51726       };
51727     } catch (std::exception& e) {
51728       {
51729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51730       };
51731     } catch (Dali::DaliException e) {
51732       {
51733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51734       };
51735     } catch (...) {
51736       {
51737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51738       };
51739     }
51740   }
51741
51742   jresult = (unsigned long)result;
51743   return jresult;
51744 }
51745
51746
51747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51748   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51749   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51750
51751   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51752   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51753   {
51754     try {
51755       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51756     } catch (std::out_of_range& e) {
51757       {
51758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51759       };
51760     } catch (std::exception& e) {
51761       {
51762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51763       };
51764     } catch (Dali::DaliException e) {
51765       {
51766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51767       };
51768     } catch (...) {
51769       {
51770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51771       };
51772     }
51773   }
51774
51775 }
51776
51777
51778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51779   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51780   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51781
51782   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51783   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51784   {
51785     try {
51786       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51787     } catch (std::out_of_range& e) {
51788       {
51789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51790       };
51791     } catch (std::exception& e) {
51792       {
51793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51794       };
51795     } catch (Dali::DaliException e) {
51796       {
51797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51798       };
51799     } catch (...) {
51800       {
51801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51802       };
51803     }
51804   }
51805
51806 }
51807
51808
51809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51810   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51811   Dali::Actor arg2 ;
51812   Dali::LongPressGesture *arg3 = 0 ;
51813   Dali::Actor *argp2 ;
51814
51815   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51816   argp2 = (Dali::Actor *)jarg2;
51817   if (!argp2) {
51818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51819     return ;
51820   }
51821   arg2 = *argp2;
51822   arg3 = (Dali::LongPressGesture *)jarg3;
51823   if (!arg3) {
51824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51825     return ;
51826   }
51827   {
51828     try {
51829       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51830     } catch (std::out_of_range& e) {
51831       {
51832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51833       };
51834     } catch (std::exception& e) {
51835       {
51836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51837       };
51838     } catch (Dali::DaliException e) {
51839       {
51840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51841       };
51842     } catch (...) {
51843       {
51844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51845       };
51846     }
51847   }
51848
51849 }
51850
51851
51852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51853   void * jresult ;
51854   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51855
51856   {
51857     try {
51858       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51859     } catch (std::out_of_range& e) {
51860       {
51861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51862       };
51863     } catch (std::exception& e) {
51864       {
51865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51866       };
51867     } catch (Dali::DaliException e) {
51868       {
51869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51870       };
51871     } catch (...) {
51872       {
51873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51874       };
51875     }
51876   }
51877
51878   jresult = (void *)result;
51879   return jresult;
51880 }
51881
51882
51883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51884   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51885
51886   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51887   {
51888     try {
51889       delete arg1;
51890     } catch (std::out_of_range& e) {
51891       {
51892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51893       };
51894     } catch (std::exception& e) {
51895       {
51896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51897       };
51898     } catch (Dali::DaliException e) {
51899       {
51900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51901       };
51902     } catch (...) {
51903       {
51904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51905       };
51906     }
51907   }
51908
51909 }
51910
51911
51912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51913   unsigned int jresult ;
51914   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51915   bool result;
51916
51917   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51918   {
51919     try {
51920       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);
51921     } catch (std::out_of_range& e) {
51922       {
51923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51924       };
51925     } catch (std::exception& e) {
51926       {
51927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51928       };
51929     } catch (Dali::DaliException e) {
51930       {
51931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51932       };
51933     } catch (...) {
51934       {
51935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51936       };
51937     }
51938   }
51939
51940   jresult = result;
51941   return jresult;
51942 }
51943
51944
51945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51946   unsigned long jresult ;
51947   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51948   std::size_t result;
51949
51950   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51951   {
51952     try {
51953       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);
51954     } catch (std::out_of_range& e) {
51955       {
51956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51957       };
51958     } catch (std::exception& e) {
51959       {
51960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51961       };
51962     } catch (Dali::DaliException e) {
51963       {
51964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51965       };
51966     } catch (...) {
51967       {
51968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51969       };
51970     }
51971   }
51972
51973   jresult = (unsigned long)result;
51974   return jresult;
51975 }
51976
51977
51978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51979   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51980   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51981
51982   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51983   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51984   {
51985     try {
51986       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51987     } catch (std::out_of_range& e) {
51988       {
51989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51990       };
51991     } catch (std::exception& e) {
51992       {
51993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51994       };
51995     } catch (Dali::DaliException e) {
51996       {
51997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51998       };
51999     } catch (...) {
52000       {
52001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52002       };
52003     }
52004   }
52005
52006 }
52007
52008
52009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
52010   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52011   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
52012
52013   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52014   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
52015   {
52016     try {
52017       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52018     } catch (std::out_of_range& e) {
52019       {
52020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52021       };
52022     } catch (std::exception& e) {
52023       {
52024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52025       };
52026     } catch (Dali::DaliException e) {
52027       {
52028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52029       };
52030     } catch (...) {
52031       {
52032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52033       };
52034     }
52035   }
52036
52037 }
52038
52039
52040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52041   unsigned int jresult ;
52042   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52043   Dali::Actor arg2 ;
52044   Dali::TouchEvent *arg3 = 0 ;
52045   Dali::Actor *argp2 ;
52046   bool result;
52047
52048   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52049   argp2 = (Dali::Actor *)jarg2;
52050   if (!argp2) {
52051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52052     return 0;
52053   }
52054   arg2 = *argp2;
52055   arg3 = (Dali::TouchEvent *)jarg3;
52056   if (!arg3) {
52057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
52058     return 0;
52059   }
52060   {
52061     try {
52062       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
52063     } catch (std::out_of_range& e) {
52064       {
52065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52066       };
52067     } catch (std::exception& e) {
52068       {
52069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52070       };
52071     } catch (Dali::DaliException e) {
52072       {
52073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52074       };
52075     } catch (...) {
52076       {
52077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52078       };
52079     }
52080   }
52081
52082   jresult = result;
52083   return jresult;
52084 }
52085
52086
52087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
52088   void * jresult ;
52089   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
52090
52091   {
52092     try {
52093       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
52094     } catch (std::out_of_range& e) {
52095       {
52096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52097       };
52098     } catch (std::exception& e) {
52099       {
52100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52101       };
52102     } catch (Dali::DaliException e) {
52103       {
52104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52105       };
52106     } catch (...) {
52107       {
52108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52109       };
52110     }
52111   }
52112
52113   jresult = (void *)result;
52114   return jresult;
52115 }
52116
52117
52118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
52119   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52120
52121   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52122   {
52123     try {
52124       delete arg1;
52125     } catch (std::out_of_range& e) {
52126       {
52127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52128       };
52129     } catch (std::exception& e) {
52130       {
52131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52132       };
52133     } catch (Dali::DaliException e) {
52134       {
52135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52136       };
52137     } catch (...) {
52138       {
52139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52140       };
52141     }
52142   }
52143
52144 }
52145
52146
52147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
52148   unsigned int jresult ;
52149   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52150   bool result;
52151
52152   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52153   {
52154     try {
52155       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);
52156     } catch (std::out_of_range& e) {
52157       {
52158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52159       };
52160     } catch (std::exception& e) {
52161       {
52162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52163       };
52164     } catch (Dali::DaliException e) {
52165       {
52166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52167       };
52168     } catch (...) {
52169       {
52170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52171       };
52172     }
52173   }
52174
52175   jresult = result;
52176   return jresult;
52177 }
52178
52179
52180 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
52181   unsigned long jresult ;
52182   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52183   std::size_t result;
52184
52185   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52186   {
52187     try {
52188       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);
52189     } catch (std::out_of_range& e) {
52190       {
52191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52192       };
52193     } catch (std::exception& e) {
52194       {
52195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52196       };
52197     } catch (Dali::DaliException e) {
52198       {
52199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52200       };
52201     } catch (...) {
52202       {
52203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52204       };
52205     }
52206   }
52207
52208   jresult = (unsigned long)result;
52209   return jresult;
52210 }
52211
52212
52213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
52214   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52215   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52216
52217   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52218   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52219   {
52220     try {
52221       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52222     } catch (std::out_of_range& e) {
52223       {
52224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52225       };
52226     } catch (std::exception& e) {
52227       {
52228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52229       };
52230     } catch (Dali::DaliException e) {
52231       {
52232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52233       };
52234     } catch (...) {
52235       {
52236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52237       };
52238     }
52239   }
52240
52241 }
52242
52243
52244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
52245   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52246   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52247
52248   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52249   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52250   {
52251     try {
52252       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52253     } catch (std::out_of_range& e) {
52254       {
52255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52256       };
52257     } catch (std::exception& e) {
52258       {
52259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52260       };
52261     } catch (Dali::DaliException e) {
52262       {
52263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52264       };
52265     } catch (...) {
52266       {
52267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52268       };
52269     }
52270   }
52271
52272 }
52273
52274
52275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52276   unsigned int jresult ;
52277   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52278   Dali::Actor arg2 ;
52279   Dali::HoverEvent *arg3 = 0 ;
52280   Dali::Actor *argp2 ;
52281   bool result;
52282
52283   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52284   argp2 = (Dali::Actor *)jarg2;
52285   if (!argp2) {
52286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52287     return 0;
52288   }
52289   arg2 = *argp2;
52290   arg3 = (Dali::HoverEvent *)jarg3;
52291   if (!arg3) {
52292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52293     return 0;
52294   }
52295   {
52296     try {
52297       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52298     } catch (std::out_of_range& e) {
52299       {
52300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52301       };
52302     } catch (std::exception& e) {
52303       {
52304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52305       };
52306     } catch (Dali::DaliException e) {
52307       {
52308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52309       };
52310     } catch (...) {
52311       {
52312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52313       };
52314     }
52315   }
52316
52317   jresult = result;
52318   return jresult;
52319 }
52320
52321
52322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52323   void * jresult ;
52324   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52325
52326   {
52327     try {
52328       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52329     } catch (std::out_of_range& e) {
52330       {
52331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52332       };
52333     } catch (std::exception& e) {
52334       {
52335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52336       };
52337     } catch (Dali::DaliException e) {
52338       {
52339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52340       };
52341     } catch (...) {
52342       {
52343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52344       };
52345     }
52346   }
52347
52348   jresult = (void *)result;
52349   return jresult;
52350 }
52351
52352
52353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52354   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52355
52356   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52357   {
52358     try {
52359       delete arg1;
52360     } catch (std::out_of_range& e) {
52361       {
52362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52363       };
52364     } catch (std::exception& e) {
52365       {
52366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52367       };
52368     } catch (Dali::DaliException e) {
52369       {
52370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52371       };
52372     } catch (...) {
52373       {
52374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52375       };
52376     }
52377   }
52378
52379 }
52380
52381
52382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52383   unsigned int jresult ;
52384   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52385   bool result;
52386
52387   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52388   {
52389     try {
52390       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);
52391     } catch (std::out_of_range& e) {
52392       {
52393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52394       };
52395     } catch (std::exception& e) {
52396       {
52397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52398       };
52399     } catch (Dali::DaliException e) {
52400       {
52401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52402       };
52403     } catch (...) {
52404       {
52405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52406       };
52407     }
52408   }
52409
52410   jresult = result;
52411   return jresult;
52412 }
52413
52414
52415 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52416   unsigned long jresult ;
52417   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52418   std::size_t result;
52419
52420   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52421   {
52422     try {
52423       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);
52424     } catch (std::out_of_range& e) {
52425       {
52426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52427       };
52428     } catch (std::exception& e) {
52429       {
52430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52431       };
52432     } catch (Dali::DaliException e) {
52433       {
52434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52435       };
52436     } catch (...) {
52437       {
52438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52439       };
52440     }
52441   }
52442
52443   jresult = (unsigned long)result;
52444   return jresult;
52445 }
52446
52447
52448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52449   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52450   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52451
52452   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52453   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52454   {
52455     try {
52456       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52457     } catch (std::out_of_range& e) {
52458       {
52459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52460       };
52461     } catch (std::exception& e) {
52462       {
52463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52464       };
52465     } catch (Dali::DaliException e) {
52466       {
52467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52468       };
52469     } catch (...) {
52470       {
52471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52472       };
52473     }
52474   }
52475
52476 }
52477
52478
52479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52480   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52481   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52482
52483   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52484   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52485   {
52486     try {
52487       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52488     } catch (std::out_of_range& e) {
52489       {
52490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52491       };
52492     } catch (std::exception& e) {
52493       {
52494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52495       };
52496     } catch (Dali::DaliException e) {
52497       {
52498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52499       };
52500     } catch (...) {
52501       {
52502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52503       };
52504     }
52505   }
52506
52507 }
52508
52509
52510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52511   unsigned int jresult ;
52512   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52513   Dali::Actor arg2 ;
52514   Dali::WheelEvent *arg3 = 0 ;
52515   Dali::Actor *argp2 ;
52516   bool result;
52517
52518   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52519   argp2 = (Dali::Actor *)jarg2;
52520   if (!argp2) {
52521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52522     return 0;
52523   }
52524   arg2 = *argp2;
52525   arg3 = (Dali::WheelEvent *)jarg3;
52526   if (!arg3) {
52527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52528     return 0;
52529   }
52530   {
52531     try {
52532       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52533     } catch (std::out_of_range& e) {
52534       {
52535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52536       };
52537     } catch (std::exception& e) {
52538       {
52539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52540       };
52541     } catch (Dali::DaliException e) {
52542       {
52543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52544       };
52545     } catch (...) {
52546       {
52547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52548       };
52549     }
52550   }
52551
52552   jresult = result;
52553   return jresult;
52554 }
52555
52556
52557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52558   void * jresult ;
52559   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52560
52561   {
52562     try {
52563       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52564     } catch (std::out_of_range& e) {
52565       {
52566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52567       };
52568     } catch (std::exception& e) {
52569       {
52570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52571       };
52572     } catch (Dali::DaliException e) {
52573       {
52574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52575       };
52576     } catch (...) {
52577       {
52578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52579       };
52580     }
52581   }
52582
52583   jresult = (void *)result;
52584   return jresult;
52585 }
52586
52587
52588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52589   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52590
52591   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52592   {
52593     try {
52594       delete arg1;
52595     } catch (std::out_of_range& e) {
52596       {
52597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52598       };
52599     } catch (std::exception& e) {
52600       {
52601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52602       };
52603     } catch (Dali::DaliException e) {
52604       {
52605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52606       };
52607     } catch (...) {
52608       {
52609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52610       };
52611     }
52612   }
52613
52614 }
52615
52616
52617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52618   unsigned int jresult ;
52619   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52620   bool result;
52621
52622   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52623   {
52624     try {
52625       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52626     } catch (std::out_of_range& e) {
52627       {
52628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52629       };
52630     } catch (std::exception& e) {
52631       {
52632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52633       };
52634     } catch (Dali::DaliException e) {
52635       {
52636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52637       };
52638     } catch (...) {
52639       {
52640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52641       };
52642     }
52643   }
52644
52645   jresult = result;
52646   return jresult;
52647 }
52648
52649
52650 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52651   unsigned long jresult ;
52652   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52653   std::size_t result;
52654
52655   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52656   {
52657     try {
52658       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52659     } catch (std::out_of_range& e) {
52660       {
52661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52662       };
52663     } catch (std::exception& e) {
52664       {
52665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52666       };
52667     } catch (Dali::DaliException e) {
52668       {
52669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52670       };
52671     } catch (...) {
52672       {
52673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52674       };
52675     }
52676   }
52677
52678   jresult = (unsigned long)result;
52679   return jresult;
52680 }
52681
52682
52683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52684   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52685   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52686
52687   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52688   arg2 = (void (*)(Dali::Actor))jarg2;
52689   {
52690     try {
52691       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52692     } catch (std::out_of_range& e) {
52693       {
52694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52695       };
52696     } catch (std::exception& e) {
52697       {
52698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52699       };
52700     } catch (Dali::DaliException e) {
52701       {
52702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52703       };
52704     } catch (...) {
52705       {
52706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52707       };
52708     }
52709   }
52710
52711 }
52712
52713
52714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52715   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52716   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52717
52718   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52719   arg2 = (void (*)(Dali::Actor))jarg2;
52720   {
52721     try {
52722       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52723     } catch (std::out_of_range& e) {
52724       {
52725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52726       };
52727     } catch (std::exception& e) {
52728       {
52729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52730       };
52731     } catch (Dali::DaliException e) {
52732       {
52733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52734       };
52735     } catch (...) {
52736       {
52737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52738       };
52739     }
52740   }
52741
52742 }
52743
52744
52745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52746   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52747   Dali::Actor arg2 ;
52748   Dali::Actor *argp2 ;
52749
52750   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52751   argp2 = (Dali::Actor *)jarg2;
52752   if (!argp2) {
52753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52754     return ;
52755   }
52756   arg2 = *argp2;
52757   {
52758     try {
52759       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52760     } catch (std::out_of_range& e) {
52761       {
52762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52763       };
52764     } catch (std::exception& e) {
52765       {
52766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52767       };
52768     } catch (Dali::DaliException e) {
52769       {
52770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52771       };
52772     } catch (...) {
52773       {
52774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52775       };
52776     }
52777   }
52778
52779 }
52780
52781
52782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52783   void * jresult ;
52784   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52785
52786   {
52787     try {
52788       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52789     } catch (std::out_of_range& e) {
52790       {
52791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52792       };
52793     } catch (std::exception& e) {
52794       {
52795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52796       };
52797     } catch (Dali::DaliException e) {
52798       {
52799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52800       };
52801     } catch (...) {
52802       {
52803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52804       };
52805     }
52806   }
52807
52808   jresult = (void *)result;
52809   return jresult;
52810 }
52811
52812
52813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52814   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52815
52816   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52817   {
52818     try {
52819       delete arg1;
52820     } catch (std::out_of_range& e) {
52821       {
52822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52823       };
52824     } catch (std::exception& e) {
52825       {
52826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52827       };
52828     } catch (Dali::DaliException e) {
52829       {
52830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52831       };
52832     } catch (...) {
52833       {
52834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52835       };
52836     }
52837   }
52838
52839 }
52840
52841
52842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52843   unsigned int jresult ;
52844   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52845   bool result;
52846
52847   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52848   {
52849     try {
52850       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52851     } catch (std::out_of_range& e) {
52852       {
52853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52854       };
52855     } catch (std::exception& e) {
52856       {
52857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52858       };
52859     } catch (Dali::DaliException e) {
52860       {
52861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52862       };
52863     } catch (...) {
52864       {
52865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52866       };
52867     }
52868   }
52869
52870   jresult = result;
52871   return jresult;
52872 }
52873
52874
52875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52876   unsigned long jresult ;
52877   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52878   std::size_t result;
52879
52880   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52881   {
52882     try {
52883       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52884     } catch (std::out_of_range& e) {
52885       {
52886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52887       };
52888     } catch (std::exception& e) {
52889       {
52890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52891       };
52892     } catch (Dali::DaliException e) {
52893       {
52894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52895       };
52896     } catch (...) {
52897       {
52898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52899       };
52900     }
52901   }
52902
52903   jresult = (unsigned long)result;
52904   return jresult;
52905 }
52906
52907
52908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52909   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52910   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52911
52912   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52913   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52914   {
52915     try {
52916       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52917     } catch (std::out_of_range& e) {
52918       {
52919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52920       };
52921     } catch (std::exception& e) {
52922       {
52923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52924       };
52925     } catch (Dali::DaliException e) {
52926       {
52927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52928       };
52929     } catch (...) {
52930       {
52931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52932       };
52933     }
52934   }
52935
52936 }
52937
52938
52939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52940   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52941   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52942
52943   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52944   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52945   {
52946     try {
52947       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52948     } catch (std::out_of_range& e) {
52949       {
52950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52951       };
52952     } catch (std::exception& e) {
52953       {
52954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52955       };
52956     } catch (Dali::DaliException e) {
52957       {
52958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52959       };
52960     } catch (...) {
52961       {
52962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52963       };
52964     }
52965   }
52966
52967 }
52968
52969
52970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52971   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52972   Dali::KeyEvent *arg2 = 0 ;
52973
52974   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52975   arg2 = (Dali::KeyEvent *)jarg2;
52976   if (!arg2) {
52977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52978     return ;
52979   }
52980   {
52981     try {
52982       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52983     } catch (std::out_of_range& e) {
52984       {
52985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52986       };
52987     } catch (std::exception& e) {
52988       {
52989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52990       };
52991     } catch (Dali::DaliException e) {
52992       {
52993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52994       };
52995     } catch (...) {
52996       {
52997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52998       };
52999     }
53000   }
53001
53002 }
53003
53004
53005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
53006   void * jresult ;
53007   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
53008
53009   {
53010     try {
53011       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
53012     } catch (std::out_of_range& e) {
53013       {
53014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53015       };
53016     } catch (std::exception& e) {
53017       {
53018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53019       };
53020     } catch (Dali::DaliException e) {
53021       {
53022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53023       };
53024     } catch (...) {
53025       {
53026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53027       };
53028     }
53029   }
53030
53031   jresult = (void *)result;
53032   return jresult;
53033 }
53034
53035
53036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
53037   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53038
53039   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53040   {
53041     try {
53042       delete arg1;
53043     } catch (std::out_of_range& e) {
53044       {
53045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53046       };
53047     } catch (std::exception& e) {
53048       {
53049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53050       };
53051     } catch (Dali::DaliException e) {
53052       {
53053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53054       };
53055     } catch (...) {
53056       {
53057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53058       };
53059     }
53060   }
53061
53062 }
53063
53064
53065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
53066   unsigned int jresult ;
53067   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53068   bool result;
53069
53070   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53071   {
53072     try {
53073       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
53074     } catch (std::out_of_range& e) {
53075       {
53076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53077       };
53078     } catch (std::exception& e) {
53079       {
53080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53081       };
53082     } catch (Dali::DaliException e) {
53083       {
53084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53085       };
53086     } catch (...) {
53087       {
53088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53089       };
53090     }
53091   }
53092
53093   jresult = result;
53094   return jresult;
53095 }
53096
53097
53098 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
53099   unsigned long jresult ;
53100   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53101   std::size_t result;
53102
53103   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53104   {
53105     try {
53106       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
53107     } catch (std::out_of_range& e) {
53108       {
53109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53110       };
53111     } catch (std::exception& e) {
53112       {
53113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53114       };
53115     } catch (Dali::DaliException e) {
53116       {
53117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53118       };
53119     } catch (...) {
53120       {
53121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53122       };
53123     }
53124   }
53125
53126   jresult = (unsigned long)result;
53127   return jresult;
53128 }
53129
53130
53131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
53132   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53133   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
53134
53135   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53136   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
53137   {
53138     try {
53139       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53140     } catch (std::out_of_range& e) {
53141       {
53142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53143       };
53144     } catch (std::exception& e) {
53145       {
53146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53147       };
53148     } catch (Dali::DaliException e) {
53149       {
53150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53151       };
53152     } catch (...) {
53153       {
53154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53155       };
53156     }
53157   }
53158
53159 }
53160
53161
53162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
53163   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53164   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
53165
53166   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53167   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
53168   {
53169     try {
53170       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53171     } catch (std::out_of_range& e) {
53172       {
53173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53174       };
53175     } catch (std::exception& e) {
53176       {
53177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53178       };
53179     } catch (Dali::DaliException e) {
53180       {
53181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53182       };
53183     } catch (...) {
53184       {
53185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53186       };
53187     }
53188   }
53189
53190 }
53191
53192
53193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
53194   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53195   Dali::TouchEvent *arg2 = 0 ;
53196
53197   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53198   arg2 = (Dali::TouchEvent *)jarg2;
53199   if (!arg2) {
53200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
53201     return ;
53202   }
53203   {
53204     try {
53205       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
53206     } catch (std::out_of_range& e) {
53207       {
53208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53209       };
53210     } catch (std::exception& e) {
53211       {
53212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53213       };
53214     } catch (Dali::DaliException e) {
53215       {
53216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53217       };
53218     } catch (...) {
53219       {
53220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53221       };
53222     }
53223   }
53224
53225 }
53226
53227
53228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
53229   void * jresult ;
53230   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
53231
53232   {
53233     try {
53234       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
53235     } catch (std::out_of_range& e) {
53236       {
53237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53238       };
53239     } catch (std::exception& e) {
53240       {
53241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53242       };
53243     } catch (Dali::DaliException e) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53246       };
53247     } catch (...) {
53248       {
53249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53250       };
53251     }
53252   }
53253
53254   jresult = (void *)result;
53255   return jresult;
53256 }
53257
53258
53259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
53260   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53261
53262   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53263   {
53264     try {
53265       delete arg1;
53266     } catch (std::out_of_range& e) {
53267       {
53268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53269       };
53270     } catch (std::exception& e) {
53271       {
53272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53273       };
53274     } catch (Dali::DaliException e) {
53275       {
53276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53277       };
53278     } catch (...) {
53279       {
53280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53281       };
53282     }
53283   }
53284
53285 }
53286
53287
53288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53289   unsigned int jresult ;
53290   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53291   bool result;
53292
53293   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53294   {
53295     try {
53296       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53297     } catch (std::out_of_range& e) {
53298       {
53299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53300       };
53301     } catch (std::exception& e) {
53302       {
53303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53304       };
53305     } catch (Dali::DaliException e) {
53306       {
53307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53308       };
53309     } catch (...) {
53310       {
53311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53312       };
53313     }
53314   }
53315
53316   jresult = result;
53317   return jresult;
53318 }
53319
53320
53321 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53322   unsigned long jresult ;
53323   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53324   std::size_t result;
53325
53326   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53327   {
53328     try {
53329       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53330     } catch (std::out_of_range& e) {
53331       {
53332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53333       };
53334     } catch (std::exception& e) {
53335       {
53336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53337       };
53338     } catch (Dali::DaliException e) {
53339       {
53340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53341       };
53342     } catch (...) {
53343       {
53344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53345       };
53346     }
53347   }
53348
53349   jresult = (unsigned long)result;
53350   return jresult;
53351 }
53352
53353
53354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53355   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53356   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53357
53358   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53359   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53360   {
53361     try {
53362       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53363     } catch (std::out_of_range& e) {
53364       {
53365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53366       };
53367     } catch (std::exception& e) {
53368       {
53369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53370       };
53371     } catch (Dali::DaliException e) {
53372       {
53373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53374       };
53375     } catch (...) {
53376       {
53377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53378       };
53379     }
53380   }
53381
53382 }
53383
53384
53385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53386   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53387   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53388
53389   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53390   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53391   {
53392     try {
53393       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53394     } catch (std::out_of_range& e) {
53395       {
53396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53397       };
53398     } catch (std::exception& e) {
53399       {
53400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53401       };
53402     } catch (Dali::DaliException e) {
53403       {
53404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53405       };
53406     } catch (...) {
53407       {
53408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53409       };
53410     }
53411   }
53412
53413 }
53414
53415
53416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53417   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53418   Dali::WheelEvent *arg2 = 0 ;
53419
53420   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53421   arg2 = (Dali::WheelEvent *)jarg2;
53422   if (!arg2) {
53423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53424     return ;
53425   }
53426   {
53427     try {
53428       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53429     } catch (std::out_of_range& e) {
53430       {
53431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53432       };
53433     } catch (std::exception& e) {
53434       {
53435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53436       };
53437     } catch (Dali::DaliException e) {
53438       {
53439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53440       };
53441     } catch (...) {
53442       {
53443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53444       };
53445     }
53446   }
53447
53448 }
53449
53450
53451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53452   void * jresult ;
53453   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53454
53455   {
53456     try {
53457       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53458     } catch (std::out_of_range& e) {
53459       {
53460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53461       };
53462     } catch (std::exception& e) {
53463       {
53464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53465       };
53466     } catch (Dali::DaliException e) {
53467       {
53468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53469       };
53470     } catch (...) {
53471       {
53472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53473       };
53474     }
53475   }
53476
53477   jresult = (void *)result;
53478   return jresult;
53479 }
53480
53481
53482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53483   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53484
53485   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53486   {
53487     try {
53488       delete arg1;
53489     } catch (std::out_of_range& e) {
53490       {
53491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53492       };
53493     } catch (std::exception& e) {
53494       {
53495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53496       };
53497     } catch (Dali::DaliException e) {
53498       {
53499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53500       };
53501     } catch (...) {
53502       {
53503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53504       };
53505     }
53506   }
53507
53508 }
53509
53510
53511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53512   void * jresult ;
53513   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53514
53515   {
53516     try {
53517       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53518     } catch (std::out_of_range& e) {
53519       {
53520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53521       };
53522     } catch (std::exception& e) {
53523       {
53524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53525       };
53526     } catch (Dali::DaliException e) {
53527       {
53528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53529       };
53530     } catch (...) {
53531       {
53532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53533       };
53534     }
53535   }
53536
53537   jresult = (void *)result;
53538   return jresult;
53539 }
53540
53541
53542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53543   void * jresult ;
53544   Dali::Radian arg1 ;
53545   Dali::Radian arg2 ;
53546   Dali::Radian *argp1 ;
53547   Dali::Radian *argp2 ;
53548   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53549
53550   argp1 = (Dali::Radian *)jarg1;
53551   if (!argp1) {
53552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53553     return 0;
53554   }
53555   arg1 = *argp1;
53556   argp2 = (Dali::Radian *)jarg2;
53557   if (!argp2) {
53558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53559     return 0;
53560   }
53561   arg2 = *argp2;
53562   {
53563     try {
53564       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53565     } catch (std::out_of_range& e) {
53566       {
53567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53568       };
53569     } catch (std::exception& e) {
53570       {
53571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53572       };
53573     } catch (Dali::DaliException e) {
53574       {
53575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53576       };
53577     } catch (...) {
53578       {
53579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53580       };
53581     }
53582   }
53583
53584   jresult = (void *)result;
53585   return jresult;
53586 }
53587
53588
53589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53590   void * jresult ;
53591   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53592   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53593
53594   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53595   if (!arg1) {
53596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53597     return 0;
53598   }
53599   {
53600     try {
53601       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53602     } catch (std::out_of_range& e) {
53603       {
53604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53605       };
53606     } catch (std::exception& e) {
53607       {
53608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53609       };
53610     } catch (Dali::DaliException e) {
53611       {
53612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53613       };
53614     } catch (...) {
53615       {
53616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53617       };
53618     }
53619   }
53620
53621   jresult = (void *)result;
53622   return jresult;
53623 }
53624
53625
53626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53627   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53628   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53629
53630   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53631   arg2 = (Dali::Radian *)jarg2;
53632   if (arg1) (arg1)->first = *arg2;
53633 }
53634
53635
53636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53637   void * jresult ;
53638   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53639   Dali::Radian *result = 0 ;
53640
53641   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53642   result = (Dali::Radian *)& ((arg1)->first);
53643   jresult = (void *)result;
53644   return jresult;
53645 }
53646
53647
53648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53649   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53650   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53651
53652   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53653   arg2 = (Dali::Radian *)jarg2;
53654   if (arg1) (arg1)->second = *arg2;
53655 }
53656
53657
53658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53659   void * jresult ;
53660   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53661   Dali::Radian *result = 0 ;
53662
53663   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53664   result = (Dali::Radian *)& ((arg1)->second);
53665   jresult = (void *)result;
53666   return jresult;
53667 }
53668
53669
53670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53671   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53672
53673   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53674   {
53675     try {
53676       delete arg1;
53677     } catch (std::out_of_range& e) {
53678       {
53679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53680       };
53681     } catch (std::exception& e) {
53682       {
53683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53684       };
53685     } catch (Dali::DaliException e) {
53686       {
53687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53688       };
53689     } catch (...) {
53690       {
53691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53692       };
53693     }
53694   }
53695
53696 }
53697
53698
53699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53700   unsigned int jresult ;
53701   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53702   bool result;
53703
53704   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53705   {
53706     try {
53707       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);
53708     } catch (std::out_of_range& e) {
53709       {
53710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53711       };
53712     } catch (std::exception& e) {
53713       {
53714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53715       };
53716     } catch (Dali::DaliException e) {
53717       {
53718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53719       };
53720     } catch (...) {
53721       {
53722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53723       };
53724     }
53725   }
53726
53727   jresult = result;
53728   return jresult;
53729 }
53730
53731
53732 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53733   unsigned long jresult ;
53734   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53735   std::size_t result;
53736
53737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53738   {
53739     try {
53740       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);
53741     } catch (std::out_of_range& e) {
53742       {
53743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53744       };
53745     } catch (std::exception& e) {
53746       {
53747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53748       };
53749     } catch (Dali::DaliException e) {
53750       {
53751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53752       };
53753     } catch (...) {
53754       {
53755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53756       };
53757     }
53758   }
53759
53760   jresult = (unsigned long)result;
53761   return jresult;
53762 }
53763
53764
53765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53766   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53767   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53768
53769   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53770   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53771   {
53772     try {
53773       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53774     } catch (std::out_of_range& e) {
53775       {
53776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53777       };
53778     } catch (std::exception& e) {
53779       {
53780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53781       };
53782     } catch (Dali::DaliException e) {
53783       {
53784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53785       };
53786     } catch (...) {
53787       {
53788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53789       };
53790     }
53791   }
53792
53793 }
53794
53795
53796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53797   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53798   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53799
53800   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53801   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53802   {
53803     try {
53804       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53805     } catch (std::out_of_range& e) {
53806       {
53807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53808       };
53809     } catch (std::exception& e) {
53810       {
53811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53812       };
53813     } catch (Dali::DaliException e) {
53814       {
53815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53816       };
53817     } catch (...) {
53818       {
53819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53820       };
53821     }
53822   }
53823
53824 }
53825
53826
53827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53828   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53829   Dali::Actor arg2 ;
53830   Dali::PanGesture *arg3 = 0 ;
53831   Dali::Actor *argp2 ;
53832
53833   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53834   argp2 = (Dali::Actor *)jarg2;
53835   if (!argp2) {
53836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53837     return ;
53838   }
53839   arg2 = *argp2;
53840   arg3 = (Dali::PanGesture *)jarg3;
53841   if (!arg3) {
53842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53843     return ;
53844   }
53845   {
53846     try {
53847       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53848     } catch (std::out_of_range& e) {
53849       {
53850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53851       };
53852     } catch (std::exception& e) {
53853       {
53854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53855       };
53856     } catch (Dali::DaliException e) {
53857       {
53858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53859       };
53860     } catch (...) {
53861       {
53862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53863       };
53864     }
53865   }
53866
53867 }
53868
53869
53870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53871   void * jresult ;
53872   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53873
53874   {
53875     try {
53876       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53877     } catch (std::out_of_range& e) {
53878       {
53879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53880       };
53881     } catch (std::exception& e) {
53882       {
53883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53884       };
53885     } catch (Dali::DaliException e) {
53886       {
53887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53888       };
53889     } catch (...) {
53890       {
53891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53892       };
53893     }
53894   }
53895
53896   jresult = (void *)result;
53897   return jresult;
53898 }
53899
53900
53901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53902   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53903
53904   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53905   {
53906     try {
53907       delete arg1;
53908     } catch (std::out_of_range& e) {
53909       {
53910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53911       };
53912     } catch (std::exception& e) {
53913       {
53914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53915       };
53916     } catch (Dali::DaliException e) {
53917       {
53918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53919       };
53920     } catch (...) {
53921       {
53922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53923       };
53924     }
53925   }
53926
53927 }
53928
53929
53930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53931   unsigned int jresult ;
53932   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53933   bool result;
53934
53935   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53936   {
53937     try {
53938       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);
53939     } catch (std::out_of_range& e) {
53940       {
53941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53942       };
53943     } catch (std::exception& e) {
53944       {
53945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53946       };
53947     } catch (Dali::DaliException e) {
53948       {
53949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53950       };
53951     } catch (...) {
53952       {
53953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53954       };
53955     }
53956   }
53957
53958   jresult = result;
53959   return jresult;
53960 }
53961
53962
53963 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53964   unsigned long jresult ;
53965   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53966   std::size_t result;
53967
53968   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53969   {
53970     try {
53971       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);
53972     } catch (std::out_of_range& e) {
53973       {
53974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53975       };
53976     } catch (std::exception& e) {
53977       {
53978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53979       };
53980     } catch (Dali::DaliException e) {
53981       {
53982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53983       };
53984     } catch (...) {
53985       {
53986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53987       };
53988     }
53989   }
53990
53991   jresult = (unsigned long)result;
53992   return jresult;
53993 }
53994
53995
53996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53997   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53998   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53999
54000   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54001   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54002   {
54003     try {
54004       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54005     } catch (std::out_of_range& e) {
54006       {
54007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54008       };
54009     } catch (std::exception& e) {
54010       {
54011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54012       };
54013     } catch (Dali::DaliException e) {
54014       {
54015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54016       };
54017     } catch (...) {
54018       {
54019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54020       };
54021     }
54022   }
54023
54024 }
54025
54026
54027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54028   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54029   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54030
54031   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54032   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54033   {
54034     try {
54035       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54036     } catch (std::out_of_range& e) {
54037       {
54038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54039       };
54040     } catch (std::exception& e) {
54041       {
54042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54043       };
54044     } catch (Dali::DaliException e) {
54045       {
54046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54047       };
54048     } catch (...) {
54049       {
54050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54051       };
54052     }
54053   }
54054
54055 }
54056
54057
54058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54059   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54060   Dali::Actor arg2 ;
54061   Dali::PinchGesture *arg3 = 0 ;
54062   Dali::Actor *argp2 ;
54063
54064   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54065   argp2 = (Dali::Actor *)jarg2;
54066   if (!argp2) {
54067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54068     return ;
54069   }
54070   arg2 = *argp2;
54071   arg3 = (Dali::PinchGesture *)jarg3;
54072   if (!arg3) {
54073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
54074     return ;
54075   }
54076   {
54077     try {
54078       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
54079     } catch (std::out_of_range& e) {
54080       {
54081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54082       };
54083     } catch (std::exception& e) {
54084       {
54085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54086       };
54087     } catch (Dali::DaliException e) {
54088       {
54089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54090       };
54091     } catch (...) {
54092       {
54093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54094       };
54095     }
54096   }
54097
54098 }
54099
54100
54101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
54102   void * jresult ;
54103   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
54104
54105   {
54106     try {
54107       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
54108     } catch (std::out_of_range& e) {
54109       {
54110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54111       };
54112     } catch (std::exception& e) {
54113       {
54114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54115       };
54116     } catch (Dali::DaliException e) {
54117       {
54118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54119       };
54120     } catch (...) {
54121       {
54122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54123       };
54124     }
54125   }
54126
54127   jresult = (void *)result;
54128   return jresult;
54129 }
54130
54131
54132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
54133   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54134
54135   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54136   {
54137     try {
54138       delete arg1;
54139     } catch (std::out_of_range& e) {
54140       {
54141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54142       };
54143     } catch (std::exception& e) {
54144       {
54145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54146       };
54147     } catch (Dali::DaliException e) {
54148       {
54149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54150       };
54151     } catch (...) {
54152       {
54153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54154       };
54155     }
54156   }
54157
54158 }
54159
54160
54161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
54162   unsigned int jresult ;
54163   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54164   bool result;
54165
54166   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54167   {
54168     try {
54169       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);
54170     } catch (std::out_of_range& e) {
54171       {
54172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54173       };
54174     } catch (std::exception& e) {
54175       {
54176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54177       };
54178     } catch (Dali::DaliException e) {
54179       {
54180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54181       };
54182     } catch (...) {
54183       {
54184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54185       };
54186     }
54187   }
54188
54189   jresult = result;
54190   return jresult;
54191 }
54192
54193
54194 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54195   unsigned long jresult ;
54196   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54197   std::size_t result;
54198
54199   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54200   {
54201     try {
54202       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);
54203     } catch (std::out_of_range& e) {
54204       {
54205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54206       };
54207     } catch (std::exception& e) {
54208       {
54209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54210       };
54211     } catch (Dali::DaliException e) {
54212       {
54213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54214       };
54215     } catch (...) {
54216       {
54217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54218       };
54219     }
54220   }
54221
54222   jresult = (unsigned long)result;
54223   return jresult;
54224 }
54225
54226
54227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54228   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54229   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54230
54231   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54232   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54233   {
54234     try {
54235       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54236     } catch (std::out_of_range& e) {
54237       {
54238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54239       };
54240     } catch (std::exception& e) {
54241       {
54242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54243       };
54244     } catch (Dali::DaliException e) {
54245       {
54246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54247       };
54248     } catch (...) {
54249       {
54250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54251       };
54252     }
54253   }
54254
54255 }
54256
54257
54258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54259   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54260   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54261
54262   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54263   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54264   {
54265     try {
54266       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54267     } catch (std::out_of_range& e) {
54268       {
54269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54270       };
54271     } catch (std::exception& e) {
54272       {
54273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54274       };
54275     } catch (Dali::DaliException e) {
54276       {
54277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54278       };
54279     } catch (...) {
54280       {
54281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54282       };
54283     }
54284   }
54285
54286 }
54287
54288
54289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54290   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54291   Dali::Actor arg2 ;
54292   Dali::TapGesture *arg3 = 0 ;
54293   Dali::Actor *argp2 ;
54294
54295   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54296   argp2 = (Dali::Actor *)jarg2;
54297   if (!argp2) {
54298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54299     return ;
54300   }
54301   arg2 = *argp2;
54302   arg3 = (Dali::TapGesture *)jarg3;
54303   if (!arg3) {
54304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54305     return ;
54306   }
54307   {
54308     try {
54309       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54310     } catch (std::out_of_range& e) {
54311       {
54312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54313       };
54314     } catch (std::exception& e) {
54315       {
54316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54317       };
54318     } catch (Dali::DaliException e) {
54319       {
54320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54321       };
54322     } catch (...) {
54323       {
54324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54325       };
54326     }
54327   }
54328
54329 }
54330
54331
54332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54333   void * jresult ;
54334   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54335
54336   {
54337     try {
54338       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54339     } catch (std::out_of_range& e) {
54340       {
54341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54342       };
54343     } catch (std::exception& e) {
54344       {
54345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54346       };
54347     } catch (Dali::DaliException e) {
54348       {
54349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54350       };
54351     } catch (...) {
54352       {
54353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54354       };
54355     }
54356   }
54357
54358   jresult = (void *)result;
54359   return jresult;
54360 }
54361
54362
54363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54364   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54365
54366   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54367   {
54368     try {
54369       delete arg1;
54370     } catch (std::out_of_range& e) {
54371       {
54372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54373       };
54374     } catch (std::exception& e) {
54375       {
54376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54377       };
54378     } catch (Dali::DaliException e) {
54379       {
54380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54381       };
54382     } catch (...) {
54383       {
54384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54385       };
54386     }
54387   }
54388
54389 }
54390
54391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54392   unsigned int jresult ;
54393   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54394   bool result = false;
54395
54396   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54397   {
54398     try {
54399       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);
54400     } catch (std::out_of_range& e) {
54401       {
54402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54403       };
54404     } catch (std::exception& e) {
54405       {
54406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54407       };
54408     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54409   }
54410   jresult = result;
54411   return jresult;
54412 }
54413
54414 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54415   unsigned long jresult ;
54416   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54417   std::size_t result = 0;
54418
54419   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54420   {
54421     try {
54422       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);
54423     } catch (std::out_of_range& e) {
54424       {
54425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54426       };
54427     } catch (std::exception& e) {
54428       {
54429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54430       };
54431     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54432   }
54433   jresult = (unsigned long)result;
54434   return jresult;
54435 }
54436
54437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54438   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54439   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54440
54441   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54442   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54443   {
54444     try {
54445       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54446     } catch (std::out_of_range& e) {
54447       {
54448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54449       };
54450     } catch (std::exception& e) {
54451       {
54452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54453       };
54454     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54455   }
54456 }
54457
54458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54459   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54460   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54461
54462   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54463   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54464   {
54465     try {
54466       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54467     } catch (std::out_of_range& e) {
54468       {
54469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54470       };
54471     } catch (std::exception& e) {
54472       {
54473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54474       };
54475     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54476   }
54477 }
54478
54479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54480   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54481   Dali::Actor arg2 ;
54482   //bool arg3 ;
54483   Dali::LayoutDirection::Type arg4 ;
54484   Dali::Actor *argp2 ;
54485
54486   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54487   argp2 = (Dali::Actor *)jarg2;
54488   if (!argp2) {
54489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54490     return ;
54491   }
54492   arg2 = *argp2;
54493   //arg3 = jarg3 ? true : false;
54494   arg4 = (Dali::LayoutDirection::Type)jarg4;
54495   {
54496     try {
54497       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54498     } catch (std::out_of_range& e) {
54499       {
54500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54501       };
54502     } catch (std::exception& e) {
54503       {
54504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54505       };
54506     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54507   }
54508 }
54509
54510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54511   void * jresult ;
54512   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54513
54514   {
54515     try {
54516       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54517     } catch (std::out_of_range& e) {
54518       {
54519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54520       };
54521     } catch (std::exception& e) {
54522       {
54523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54524       };
54525     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54526   }
54527   jresult = (void *)result;
54528   return jresult;
54529 }
54530
54531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54532   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54533
54534   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54535   {
54536     try {
54537       delete arg1;
54538     } catch (std::out_of_range& e) {
54539       {
54540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54541       };
54542     } catch (std::exception& e) {
54543       {
54544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54545       };
54546     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54547   }
54548 }
54549
54550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54551   unsigned int jresult ;
54552   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54553   bool result;
54554
54555   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54556   {
54557     try {
54558       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);
54559     } catch (std::out_of_range& e) {
54560       {
54561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54562       };
54563     } catch (std::exception& e) {
54564       {
54565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54566       };
54567     } catch (Dali::DaliException e) {
54568       {
54569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54570       };
54571     } catch (...) {
54572       {
54573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54574       };
54575     }
54576   }
54577
54578   jresult = result;
54579   return jresult;
54580 }
54581
54582
54583 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54584   unsigned long jresult ;
54585   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54586   std::size_t result;
54587
54588   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54589   {
54590     try {
54591       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);
54592     } catch (std::out_of_range& e) {
54593       {
54594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54595       };
54596     } catch (std::exception& e) {
54597       {
54598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54599       };
54600     } catch (Dali::DaliException e) {
54601       {
54602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54603       };
54604     } catch (...) {
54605       {
54606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54607       };
54608     }
54609   }
54610
54611   jresult = (unsigned long)result;
54612   return jresult;
54613 }
54614
54615
54616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54617   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54618   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54619
54620   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54621   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54622   {
54623     try {
54624       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54625     } catch (std::out_of_range& e) {
54626       {
54627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54628       };
54629     } catch (std::exception& e) {
54630       {
54631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54632       };
54633     } catch (Dali::DaliException e) {
54634       {
54635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54636       };
54637     } catch (...) {
54638       {
54639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54640       };
54641     }
54642   }
54643
54644 }
54645
54646
54647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54648   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54649   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54650
54651   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54652   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54653   {
54654     try {
54655       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54656     } catch (std::out_of_range& e) {
54657       {
54658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54659       };
54660     } catch (std::exception& e) {
54661       {
54662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54663       };
54664     } catch (Dali::DaliException e) {
54665       {
54666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54667       };
54668     } catch (...) {
54669       {
54670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54671       };
54672     }
54673   }
54674
54675 }
54676
54677
54678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54679   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54680   Dali::Actor arg2 ;
54681   bool arg3 ;
54682   Dali::DevelActor::VisibilityChange::Type arg4 ;
54683   Dali::Actor *argp2 ;
54684
54685   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54686   argp2 = (Dali::Actor *)jarg2;
54687   if (!argp2) {
54688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54689     return ;
54690   }
54691   arg2 = *argp2;
54692   arg3 = jarg3 ? true : false;
54693   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54694   {
54695     try {
54696       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54697     } catch (std::out_of_range& e) {
54698       {
54699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54700       };
54701     } catch (std::exception& e) {
54702       {
54703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54704       };
54705     } catch (Dali::DaliException e) {
54706       {
54707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54708       };
54709     } catch (...) {
54710       {
54711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54712       };
54713     }
54714   }
54715
54716 }
54717
54718
54719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54720   void * jresult ;
54721   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54722
54723   {
54724     try {
54725       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54726     } catch (std::out_of_range& e) {
54727       {
54728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54729       };
54730     } catch (std::exception& e) {
54731       {
54732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54733       };
54734     } catch (Dali::DaliException e) {
54735       {
54736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54737       };
54738     } catch (...) {
54739       {
54740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54741       };
54742     }
54743   }
54744
54745   jresult = (void *)result;
54746   return jresult;
54747 }
54748
54749
54750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54751   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54752
54753   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54754   {
54755     try {
54756       delete arg1;
54757     } catch (std::out_of_range& e) {
54758       {
54759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54760       };
54761     } catch (std::exception& e) {
54762       {
54763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54764       };
54765     } catch (Dali::DaliException e) {
54766       {
54767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54768       };
54769     } catch (...) {
54770       {
54771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54772       };
54773     }
54774   }
54775
54776 }
54777
54778
54779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54780   void * jresult ;
54781   Dali::Timer *result = 0 ;
54782
54783   {
54784     try {
54785       result = (Dali::Timer *)new Dali::Timer();
54786     } catch (std::out_of_range& e) {
54787       {
54788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54789       };
54790     } catch (std::exception& e) {
54791       {
54792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54793       };
54794     } catch (Dali::DaliException e) {
54795       {
54796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54797       };
54798     } catch (...) {
54799       {
54800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54801       };
54802     }
54803   }
54804
54805   jresult = (void *)result;
54806   return jresult;
54807 }
54808
54809
54810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54811   void * jresult ;
54812   unsigned int arg1 ;
54813   Dali::Timer result;
54814
54815   arg1 = (unsigned int)jarg1;
54816   {
54817     try {
54818       result = Dali::Timer::New(arg1);
54819     } catch (std::out_of_range& e) {
54820       {
54821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54822       };
54823     } catch (std::exception& e) {
54824       {
54825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54826       };
54827     } catch (Dali::DaliException e) {
54828       {
54829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54830       };
54831     } catch (...) {
54832       {
54833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54834       };
54835     }
54836   }
54837
54838   jresult = new Dali::Timer((const Dali::Timer &)result);
54839   return jresult;
54840 }
54841
54842
54843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
54844   void * jresult ;
54845   Dali::Timer *arg1 = 0 ;
54846   Dali::Timer *result = 0 ;
54847
54848   arg1 = (Dali::Timer *)jarg1;
54849   if (!arg1) {
54850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54851     return 0;
54852   }
54853   {
54854     try {
54855       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
54856     } catch (std::out_of_range& e) {
54857       {
54858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54859       };
54860     } catch (std::exception& e) {
54861       {
54862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54863       };
54864     } catch (Dali::DaliException e) {
54865       {
54866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54867       };
54868     } catch (...) {
54869       {
54870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54871       };
54872     }
54873   }
54874
54875   jresult = (void *)result;
54876   return jresult;
54877 }
54878
54879
54880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
54881   void * jresult ;
54882   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54883   Dali::Timer *arg2 = 0 ;
54884   Dali::Timer *result = 0 ;
54885
54886   arg1 = (Dali::Timer *)jarg1;
54887   arg2 = (Dali::Timer *)jarg2;
54888   if (!arg2) {
54889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54890     return 0;
54891   }
54892   {
54893     try {
54894       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54895     } catch (std::out_of_range& e) {
54896       {
54897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54898       };
54899     } catch (std::exception& e) {
54900       {
54901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54902       };
54903     } catch (Dali::DaliException e) {
54904       {
54905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54906       };
54907     } catch (...) {
54908       {
54909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54910       };
54911     }
54912   }
54913
54914   jresult = (void *)result;
54915   return jresult;
54916 }
54917
54918
54919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54920   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54921
54922   arg1 = (Dali::Timer *)jarg1;
54923   {
54924     try {
54925       delete arg1;
54926     } catch (std::out_of_range& e) {
54927       {
54928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54929       };
54930     } catch (std::exception& e) {
54931       {
54932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54933       };
54934     } catch (Dali::DaliException e) {
54935       {
54936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54937       };
54938     } catch (...) {
54939       {
54940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54941       };
54942     }
54943   }
54944
54945 }
54946
54947
54948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54949   void * jresult ;
54950   Dali::BaseHandle arg1 ;
54951   Dali::BaseHandle *argp1 ;
54952   Dali::Timer result;
54953
54954   argp1 = (Dali::BaseHandle *)jarg1;
54955   if (!argp1) {
54956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54957     return 0;
54958   }
54959   arg1 = *argp1;
54960   {
54961     try {
54962       result = Dali::Timer::DownCast(arg1);
54963     } catch (std::out_of_range& e) {
54964       {
54965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54966       };
54967     } catch (std::exception& e) {
54968       {
54969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54970       };
54971     } catch (Dali::DaliException e) {
54972       {
54973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54974       };
54975     } catch (...) {
54976       {
54977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54978       };
54979     }
54980   }
54981
54982   jresult = new Dali::Timer((const Dali::Timer &)result);
54983   return jresult;
54984 }
54985
54986
54987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54988   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54989
54990   arg1 = (Dali::Timer *)jarg1;
54991   {
54992     try {
54993       (arg1)->Start();
54994     } catch (std::out_of_range& e) {
54995       {
54996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54997       };
54998     } catch (std::exception& e) {
54999       {
55000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55001       };
55002     } catch (Dali::DaliException e) {
55003       {
55004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55005       };
55006     } catch (...) {
55007       {
55008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55009       };
55010     }
55011   }
55012
55013 }
55014
55015
55016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
55017   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55018
55019   arg1 = (Dali::Timer *)jarg1;
55020   {
55021     try {
55022       (arg1)->Stop();
55023     } catch (std::out_of_range& e) {
55024       {
55025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55026       };
55027     } catch (std::exception& e) {
55028       {
55029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55030       };
55031     } catch (Dali::DaliException e) {
55032       {
55033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55034       };
55035     } catch (...) {
55036       {
55037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55038       };
55039     }
55040   }
55041
55042 }
55043
55044
55045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
55046   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55047   unsigned int arg2 ;
55048
55049   arg1 = (Dali::Timer *)jarg1;
55050   arg2 = (unsigned int)jarg2;
55051   {
55052     try {
55053       (arg1)->SetInterval(arg2);
55054     } catch (std::out_of_range& e) {
55055       {
55056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55057       };
55058     } catch (std::exception& e) {
55059       {
55060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55061       };
55062     } catch (Dali::DaliException e) {
55063       {
55064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55065       };
55066     } catch (...) {
55067       {
55068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55069       };
55070     }
55071   }
55072
55073 }
55074
55075
55076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
55077   unsigned int jresult ;
55078   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55079   unsigned int result;
55080
55081   arg1 = (Dali::Timer *)jarg1;
55082   {
55083     try {
55084       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
55085     } catch (std::out_of_range& e) {
55086       {
55087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55088       };
55089     } catch (std::exception& e) {
55090       {
55091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55092       };
55093     } catch (Dali::DaliException e) {
55094       {
55095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55096       };
55097     } catch (...) {
55098       {
55099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55100       };
55101     }
55102   }
55103
55104   jresult = result;
55105   return jresult;
55106 }
55107
55108
55109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
55110   unsigned int jresult ;
55111   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55112   bool result;
55113
55114   arg1 = (Dali::Timer *)jarg1;
55115   {
55116     try {
55117       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
55118     } catch (std::out_of_range& e) {
55119       {
55120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55121       };
55122     } catch (std::exception& e) {
55123       {
55124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55125       };
55126     } catch (Dali::DaliException e) {
55127       {
55128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55129       };
55130     } catch (...) {
55131       {
55132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55133       };
55134     }
55135   }
55136
55137   jresult = result;
55138   return jresult;
55139 }
55140
55141
55142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
55143   void * jresult ;
55144   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55145   Dali::Timer::TimerSignalType *result = 0 ;
55146
55147   arg1 = (Dali::Timer *)jarg1;
55148   {
55149     try {
55150       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
55151     } catch (std::out_of_range& e) {
55152       {
55153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55154       };
55155     } catch (std::exception& e) {
55156       {
55157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55158       };
55159     } catch (Dali::DaliException e) {
55160       {
55161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55162       };
55163     } catch (...) {
55164       {
55165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55166       };
55167     }
55168   }
55169
55170   jresult = (void *)result;
55171   return jresult;
55172 }
55173
55174
55175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55176   unsigned int jresult ;
55177   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55178   bool result;
55179
55180   arg1 = (Dali::Signal< bool () > *)jarg1;
55181   {
55182     try {
55183       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55184     } catch (std::out_of_range& e) {
55185       {
55186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55187       };
55188     } catch (std::exception& e) {
55189       {
55190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55191       };
55192     } catch (Dali::DaliException e) {
55193       {
55194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55195       };
55196     } catch (...) {
55197       {
55198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55199       };
55200     }
55201   }
55202
55203   jresult = result;
55204   return jresult;
55205 }
55206
55207
55208 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55209   unsigned long jresult ;
55210   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55211   std::size_t result;
55212
55213   arg1 = (Dali::Signal< bool () > *)jarg1;
55214   {
55215     try {
55216       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55217     } catch (std::out_of_range& e) {
55218       {
55219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55220       };
55221     } catch (std::exception& e) {
55222       {
55223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55224       };
55225     } catch (Dali::DaliException e) {
55226       {
55227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55228       };
55229     } catch (...) {
55230       {
55231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55232       };
55233     }
55234   }
55235
55236   jresult = (unsigned long)result;
55237   return jresult;
55238 }
55239
55240
55241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55242   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55243   bool (*arg2)() = (bool (*)()) 0 ;
55244
55245   arg1 = (Dali::Signal< bool () > *)jarg1;
55246   arg2 = (bool (*)())jarg2;
55247   {
55248     try {
55249       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55250     } catch (std::out_of_range& e) {
55251       {
55252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55253       };
55254     } catch (std::exception& e) {
55255       {
55256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55257       };
55258     } catch (Dali::DaliException e) {
55259       {
55260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55261       };
55262     } catch (...) {
55263       {
55264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55265       };
55266     }
55267   }
55268
55269 }
55270
55271
55272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55273   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55274   bool (*arg2)() = (bool (*)()) 0 ;
55275
55276   arg1 = (Dali::Signal< bool () > *)jarg1;
55277   arg2 = (bool (*)())jarg2;
55278   {
55279     try {
55280       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55281     } catch (std::out_of_range& e) {
55282       {
55283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55284       };
55285     } catch (std::exception& e) {
55286       {
55287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55288       };
55289     } catch (Dali::DaliException e) {
55290       {
55291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55292       };
55293     } catch (...) {
55294       {
55295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55296       };
55297     }
55298   }
55299
55300 }
55301
55302
55303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55304   unsigned int jresult ;
55305   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55306   bool result;
55307
55308   arg1 = (Dali::Signal< bool () > *)jarg1;
55309   {
55310     try {
55311       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55312     } catch (std::out_of_range& e) {
55313       {
55314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55315       };
55316     } catch (std::exception& e) {
55317       {
55318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55319       };
55320     } catch (Dali::DaliException e) {
55321       {
55322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55323       };
55324     } catch (...) {
55325       {
55326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55327       };
55328     }
55329   }
55330
55331   jresult = result;
55332   return jresult;
55333 }
55334
55335
55336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55337   void * jresult ;
55338   Dali::Signal< bool () > *result = 0 ;
55339
55340   {
55341     try {
55342       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55343     } catch (std::out_of_range& e) {
55344       {
55345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55346       };
55347     } catch (std::exception& e) {
55348       {
55349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55350       };
55351     } catch (Dali::DaliException e) {
55352       {
55353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55354       };
55355     } catch (...) {
55356       {
55357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55358       };
55359     }
55360   }
55361
55362   jresult = (void *)result;
55363   return jresult;
55364 }
55365
55366
55367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55368   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55369
55370   arg1 = (Dali::Signal< bool () > *)jarg1;
55371   {
55372     try {
55373       delete arg1;
55374     } catch (std::out_of_range& e) {
55375       {
55376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55377       };
55378     } catch (std::exception& e) {
55379       {
55380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55381       };
55382     } catch (Dali::DaliException e) {
55383       {
55384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55385       };
55386     } catch (...) {
55387       {
55388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55389       };
55390     }
55391   }
55392
55393 }
55394
55395
55396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55397   int jresult ;
55398   int result;
55399
55400   {
55401     try {
55402       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55403     } catch (std::out_of_range& e) {
55404       {
55405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55406       };
55407     } catch (std::exception& e) {
55408       {
55409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55410       };
55411     } catch (Dali::DaliException e) {
55412       {
55413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55414       };
55415     } catch (...) {
55416       {
55417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55418       };
55419     }
55420   }
55421
55422   jresult = (int)result;
55423   return jresult;
55424 }
55425
55426
55427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55428   int jresult ;
55429   int result;
55430
55431   {
55432     try {
55433       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55434     } catch (std::out_of_range& e) {
55435       {
55436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55437       };
55438     } catch (std::exception& e) {
55439       {
55440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55441       };
55442     } catch (Dali::DaliException e) {
55443       {
55444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55445       };
55446     } catch (...) {
55447       {
55448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55449       };
55450     }
55451   }
55452
55453   jresult = (int)result;
55454   return jresult;
55455 }
55456
55457
55458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55459   int jresult ;
55460   int result;
55461
55462   {
55463     try {
55464       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55465     } catch (std::out_of_range& e) {
55466       {
55467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55468       };
55469     } catch (std::exception& e) {
55470       {
55471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55472       };
55473     } catch (Dali::DaliException e) {
55474       {
55475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55476       };
55477     } catch (...) {
55478       {
55479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55480       };
55481     }
55482   }
55483
55484   jresult = (int)result;
55485   return jresult;
55486 }
55487
55488
55489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55490   int jresult ;
55491   int result;
55492
55493   {
55494     try {
55495       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55496     } catch (std::out_of_range& e) {
55497       {
55498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55499       };
55500     } catch (std::exception& e) {
55501       {
55502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55503       };
55504     } catch (Dali::DaliException e) {
55505       {
55506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55507       };
55508     } catch (...) {
55509       {
55510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55511       };
55512     }
55513   }
55514
55515   jresult = (int)result;
55516   return jresult;
55517 }
55518
55519
55520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55521   int jresult ;
55522   int result;
55523
55524   {
55525     try {
55526       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55527     } catch (std::out_of_range& e) {
55528       {
55529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55530       };
55531     } catch (std::exception& e) {
55532       {
55533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55534       };
55535     } catch (Dali::DaliException e) {
55536       {
55537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55538       };
55539     } catch (...) {
55540       {
55541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55542       };
55543     }
55544   }
55545
55546   jresult = (int)result;
55547   return jresult;
55548 }
55549
55550
55551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55552   int jresult ;
55553   int result;
55554
55555   {
55556     try {
55557       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55558     } catch (std::out_of_range& e) {
55559       {
55560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55561       };
55562     } catch (std::exception& e) {
55563       {
55564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55565       };
55566     } catch (Dali::DaliException e) {
55567       {
55568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55569       };
55570     } catch (...) {
55571       {
55572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55573       };
55574     }
55575   }
55576
55577   jresult = (int)result;
55578   return jresult;
55579 }
55580
55581
55582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55583   int jresult ;
55584   int result;
55585
55586   {
55587     try {
55588       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55589     } catch (std::out_of_range& e) {
55590       {
55591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55592       };
55593     } catch (std::exception& e) {
55594       {
55595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55596       };
55597     } catch (Dali::DaliException e) {
55598       {
55599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55600       };
55601     } catch (...) {
55602       {
55603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55604       };
55605     }
55606   }
55607
55608   jresult = (int)result;
55609   return jresult;
55610 }
55611
55612
55613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55614   int jresult ;
55615   int result;
55616
55617   {
55618     try {
55619       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55620     } catch (std::out_of_range& e) {
55621       {
55622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55623       };
55624     } catch (std::exception& e) {
55625       {
55626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55627       };
55628     } catch (Dali::DaliException e) {
55629       {
55630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55631       };
55632     } catch (...) {
55633       {
55634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55635       };
55636     }
55637   }
55638
55639   jresult = (int)result;
55640   return jresult;
55641 }
55642
55643
55644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55645   int jresult ;
55646   int result;
55647
55648   {
55649     try {
55650       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55651     } catch (std::out_of_range& e) {
55652       {
55653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55654       };
55655     } catch (std::exception& e) {
55656       {
55657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55658       };
55659     } catch (Dali::DaliException e) {
55660       {
55661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55662       };
55663     } catch (...) {
55664       {
55665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55666       };
55667     }
55668   }
55669
55670   jresult = (int)result;
55671   return jresult;
55672 }
55673
55674
55675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55676   int jresult ;
55677   int result;
55678
55679   {
55680     try {
55681       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55682     } catch (std::out_of_range& e) {
55683       {
55684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55685       };
55686     } catch (std::exception& e) {
55687       {
55688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55689       };
55690     } catch (Dali::DaliException e) {
55691       {
55692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55693       };
55694     } catch (...) {
55695       {
55696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55697       };
55698     }
55699   }
55700
55701   jresult = (int)result;
55702   return jresult;
55703 }
55704
55705
55706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55707   int jresult ;
55708   int result;
55709
55710   {
55711     try {
55712       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55713     } catch (std::out_of_range& e) {
55714       {
55715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55716       };
55717     } catch (std::exception& e) {
55718       {
55719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55720       };
55721     } catch (Dali::DaliException e) {
55722       {
55723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55724       };
55725     } catch (...) {
55726       {
55727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55728       };
55729     }
55730   }
55731
55732   jresult = (int)result;
55733   return jresult;
55734 }
55735
55736
55737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55738   int jresult ;
55739   int result;
55740
55741   {
55742     try {
55743       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55744     } catch (std::out_of_range& e) {
55745       {
55746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55747       };
55748     } catch (std::exception& e) {
55749       {
55750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55751       };
55752     } catch (Dali::DaliException e) {
55753       {
55754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55755       };
55756     } catch (...) {
55757       {
55758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55759       };
55760     }
55761   }
55762
55763   jresult = (int)result;
55764   return jresult;
55765 }
55766
55767
55768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55769   int jresult ;
55770   int result;
55771
55772   {
55773     try {
55774       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55775     } catch (std::out_of_range& e) {
55776       {
55777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55778       };
55779     } catch (std::exception& e) {
55780       {
55781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55782       };
55783     } catch (Dali::DaliException e) {
55784       {
55785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55786       };
55787     } catch (...) {
55788       {
55789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55790       };
55791     }
55792   }
55793
55794   jresult = (int)result;
55795   return jresult;
55796 }
55797
55798
55799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55800   int jresult ;
55801   int result;
55802
55803   {
55804     try {
55805       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55806     } catch (std::out_of_range& e) {
55807       {
55808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55809       };
55810     } catch (std::exception& e) {
55811       {
55812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55813       };
55814     } catch (Dali::DaliException e) {
55815       {
55816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55817       };
55818     } catch (...) {
55819       {
55820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55821       };
55822     }
55823   }
55824
55825   jresult = (int)result;
55826   return jresult;
55827 }
55828
55829
55830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55831   int jresult ;
55832   int result;
55833
55834   {
55835     try {
55836       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55837     } catch (std::out_of_range& e) {
55838       {
55839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55840       };
55841     } catch (std::exception& e) {
55842       {
55843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55844       };
55845     } catch (Dali::DaliException e) {
55846       {
55847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55848       };
55849     } catch (...) {
55850       {
55851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55852       };
55853     }
55854   }
55855
55856   jresult = (int)result;
55857   return jresult;
55858 }
55859
55860
55861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55862   int jresult ;
55863   int result;
55864
55865   {
55866     try {
55867       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55868     } catch (std::out_of_range& e) {
55869       {
55870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55871       };
55872     } catch (std::exception& e) {
55873       {
55874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55875       };
55876     } catch (Dali::DaliException e) {
55877       {
55878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55879       };
55880     } catch (...) {
55881       {
55882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55883       };
55884     }
55885   }
55886
55887   jresult = (int)result;
55888   return jresult;
55889 }
55890
55891
55892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55893   int jresult ;
55894   int result;
55895
55896   {
55897     try {
55898       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55899     } catch (std::out_of_range& e) {
55900       {
55901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55902       };
55903     } catch (std::exception& e) {
55904       {
55905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55906       };
55907     } catch (Dali::DaliException e) {
55908       {
55909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55910       };
55911     } catch (...) {
55912       {
55913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55914       };
55915     }
55916   }
55917
55918   jresult = (int)result;
55919   return jresult;
55920 }
55921
55922
55923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55924   int jresult ;
55925   int result;
55926
55927   {
55928     try {
55929       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55930     } catch (std::out_of_range& e) {
55931       {
55932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55933       };
55934     } catch (std::exception& e) {
55935       {
55936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55937       };
55938     } catch (Dali::DaliException e) {
55939       {
55940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55941       };
55942     } catch (...) {
55943       {
55944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55945       };
55946     }
55947   }
55948
55949   jresult = (int)result;
55950   return jresult;
55951 }
55952
55953
55954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55955   int jresult ;
55956   int result;
55957
55958   {
55959     try {
55960       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55961     } catch (std::out_of_range& e) {
55962       {
55963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55964       };
55965     } catch (std::exception& e) {
55966       {
55967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55968       };
55969     } catch (Dali::DaliException e) {
55970       {
55971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55972       };
55973     } catch (...) {
55974       {
55975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55976       };
55977     }
55978   }
55979
55980   jresult = (int)result;
55981   return jresult;
55982 }
55983
55984
55985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55986   int jresult ;
55987   int result;
55988
55989   {
55990     try {
55991       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55992     } catch (std::out_of_range& e) {
55993       {
55994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55995       };
55996     } catch (std::exception& e) {
55997       {
55998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55999       };
56000     } catch (Dali::DaliException e) {
56001       {
56002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56003       };
56004     } catch (...) {
56005       {
56006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56007       };
56008     }
56009   }
56010
56011   jresult = (int)result;
56012   return jresult;
56013 }
56014
56015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
56016   int jresult ;
56017   int result;
56018
56019   {
56020     try {
56021       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
56022     } catch (std::out_of_range& e) {
56023       {
56024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56025       };
56026     } catch (std::exception& e) {
56027       {
56028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56029       };
56030     } catch (Dali::DaliException e) {
56031       {
56032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56033       };
56034     } catch (...) {
56035       {
56036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56037       };
56038     }
56039   }
56040
56041   jresult = (int)result;
56042   return jresult;
56043 }
56044
56045
56046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
56047   int jresult ;
56048   int result;
56049   {
56050     try
56051     {
56052       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
56053     } catch (std::out_of_range& e) {
56054       {
56055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56056       };
56057     } catch (std::exception& e) {
56058       {
56059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56060       };
56061     } catch (Dali::DaliException e) {
56062       {
56063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56064       };
56065     } catch (...) {
56066       {
56067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56068       };
56069     }
56070   }
56071
56072   jresult = (int)result;
56073   return jresult;
56074 }
56075
56076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
56077   int jresult ;
56078   int result;
56079   {
56080     try
56081     {
56082       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
56083     } catch (std::out_of_range& e) {
56084       {
56085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56086       };
56087     } catch (std::exception& e) {
56088       {
56089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56090       };
56091     } catch (Dali::DaliException e) {
56092       {
56093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56094       };
56095     } catch (...) {
56096       {
56097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56098       };
56099     }
56100   }
56101
56102   jresult = (int)result;
56103   return jresult;
56104 }
56105
56106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
56107   int jresult ;
56108   int result;
56109   {
56110     try
56111     {
56112       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
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_LOOP_COUNT_get() {
56137   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
56138 }
56139
56140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
56141   int jresult ;
56142   int result;
56143   {
56144     try
56145     {
56146       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
56147     } catch (std::out_of_range& e) {
56148       {
56149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56150       };
56151     } catch (std::exception& e) {
56152       {
56153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56154       };
56155     } catch (Dali::DaliException e) {
56156       {
56157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56158       };
56159     } catch (...) {
56160       {
56161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56162       };
56163     }
56164   }
56165
56166   jresult = (int)result;
56167   return jresult;
56168 }
56169
56170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
56171   int jresult ;
56172   int result;
56173   {
56174     try
56175     {
56176       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
56177     } catch (std::out_of_range& e) {
56178       {
56179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56180       };
56181     } catch (std::exception& e) {
56182       {
56183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56184       };
56185     } catch (Dali::DaliException e) {
56186       {
56187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56188       };
56189     } catch (...) {
56190       {
56191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56192       };
56193     }
56194   }
56195
56196   jresult = (int)result;
56197   return jresult;
56198 }
56199
56200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56201   int jresult ;
56202   int result;
56203
56204   {
56205     try {
56206       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56207     } catch (std::out_of_range& e) {
56208       {
56209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56210       };
56211     } catch (std::exception& e) {
56212       {
56213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56214       };
56215     } catch (Dali::DaliException e) {
56216       {
56217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56218       };
56219     } catch (...) {
56220       {
56221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56222       };
56223     }
56224   }
56225
56226   jresult = (int)result;
56227   return jresult;
56228 }
56229
56230
56231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56232   int jresult ;
56233   int result;
56234
56235   {
56236     try {
56237       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56238     } catch (std::out_of_range& e) {
56239       {
56240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (std::exception& e) {
56243       {
56244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56245       };
56246     } catch (Dali::DaliException e) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56249       };
56250     } catch (...) {
56251       {
56252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56253       };
56254     }
56255   }
56256
56257   jresult = (int)result;
56258   return jresult;
56259 }
56260
56261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
56262   int jresult ;
56263   int result;
56264   {
56265     try
56266     {
56267       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
56268     } catch (std::out_of_range& e) {
56269       {
56270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56271       };
56272     } catch (std::exception& e) {
56273       {
56274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56275       };
56276     } catch (...) {
56277       {
56278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56279       };
56280     }
56281   }
56282   jresult = (int)result;
56283   return jresult;
56284 }
56285
56286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56287   int jresult ;
56288   int result;
56289   {
56290     try
56291     {
56292       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56293     } catch (std::out_of_range& e) {
56294       {
56295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56296       };
56297     } catch (std::exception& e) {
56298       {
56299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56300       };
56301     } catch (...) {
56302       {
56303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56304       };
56305     }
56306   }
56307   jresult = (int)result;
56308   return jresult;
56309 }
56310
56311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56312   int jresult ;
56313   int result;
56314   {
56315     try
56316     {
56317       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56318     } catch (std::out_of_range& e) {
56319       {
56320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56321       };
56322     } catch (std::exception& e) {
56323       {
56324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56325       };
56326     } catch (...) {
56327       {
56328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56329       };
56330     }
56331   }
56332   jresult = (int)result;
56333   return jresult;
56334 }
56335
56336
56337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56338   int jresult ;
56339   int result;
56340   {
56341     try
56342     {
56343       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56344     } catch (std::out_of_range& e) {
56345       {
56346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56347       };
56348     } catch (std::exception& e) {
56349       {
56350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56351       };
56352     } catch (...) {
56353       {
56354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56355       };
56356     }
56357   }
56358   jresult = (int)result;
56359   return jresult;
56360 }
56361
56362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56363   int jresult ;
56364   int result;
56365   {
56366     try
56367     {
56368       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56369     } catch (std::out_of_range& e) {
56370       {
56371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56372       };
56373     } catch (std::exception& e) {
56374       {
56375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56376       };
56377     } catch (...) {
56378       {
56379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56380       };
56381     }
56382   }
56383   jresult = (int)result;
56384   return jresult;
56385 }
56386
56387
56388
56389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56390   int jresult ;
56391   int result;
56392
56393   {
56394     try {
56395       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56396     } catch (std::out_of_range& e) {
56397       {
56398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56399       };
56400     } catch (std::exception& e) {
56401       {
56402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56403       };
56404     } catch (Dali::DaliException e) {
56405       {
56406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56407       };
56408     } catch (...) {
56409       {
56410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56411       };
56412     }
56413   }
56414
56415   jresult = (int)result;
56416   return jresult;
56417 }
56418
56419
56420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56421   int jresult ;
56422   int result;
56423
56424   {
56425     try {
56426       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56427     } catch (std::out_of_range& e) {
56428       {
56429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56430       };
56431     } catch (std::exception& e) {
56432       {
56433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56434       };
56435     } catch (Dali::DaliException e) {
56436       {
56437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56438       };
56439     } catch (...) {
56440       {
56441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56442       };
56443     }
56444   }
56445
56446   jresult = (int)result;
56447   return jresult;
56448 }
56449
56450
56451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56452   int jresult ;
56453   int result;
56454
56455   {
56456     try {
56457       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56458     } catch (std::out_of_range& e) {
56459       {
56460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (std::exception& e) {
56463       {
56464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56465       };
56466     } catch (Dali::DaliException e) {
56467       {
56468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56469       };
56470     } catch (...) {
56471       {
56472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56473       };
56474     }
56475   }
56476
56477   jresult = (int)result;
56478   return jresult;
56479 }
56480
56481
56482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56483   int jresult ;
56484   int result;
56485
56486   {
56487     try {
56488       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56489     } catch (std::out_of_range& e) {
56490       {
56491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56492       };
56493     } catch (std::exception& e) {
56494       {
56495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56496       };
56497     } catch (Dali::DaliException e) {
56498       {
56499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56500       };
56501     } catch (...) {
56502       {
56503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56504       };
56505     }
56506   }
56507
56508   jresult = (int)result;
56509   return jresult;
56510 }
56511
56512
56513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56514   int jresult ;
56515   int result;
56516
56517   {
56518     try {
56519       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56520     } catch (std::out_of_range& e) {
56521       {
56522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56523       };
56524     } catch (std::exception& e) {
56525       {
56526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56527       };
56528     } catch (Dali::DaliException e) {
56529       {
56530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56531       };
56532     } catch (...) {
56533       {
56534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56535       };
56536     }
56537   }
56538
56539   jresult = (int)result;
56540   return jresult;
56541 }
56542
56543
56544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56545   int jresult ;
56546   int result;
56547
56548   {
56549     try {
56550       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56551     } catch (std::out_of_range& e) {
56552       {
56553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56554       };
56555     } catch (std::exception& e) {
56556       {
56557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56558       };
56559     } catch (Dali::DaliException e) {
56560       {
56561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56562       };
56563     } catch (...) {
56564       {
56565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56566       };
56567     }
56568   }
56569
56570   jresult = (int)result;
56571   return jresult;
56572 }
56573
56574
56575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56576   int jresult ;
56577   int result;
56578
56579   {
56580     try {
56581       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56582     } catch (std::out_of_range& e) {
56583       {
56584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56585       };
56586     } catch (std::exception& e) {
56587       {
56588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56589       };
56590     } catch (Dali::DaliException e) {
56591       {
56592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56593       };
56594     } catch (...) {
56595       {
56596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56597       };
56598     }
56599   }
56600
56601   jresult = (int)result;
56602   return jresult;
56603 }
56604
56605 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56606   int jresult ;
56607   int result;
56608
56609   {
56610     try {
56611       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56612     } catch (std::out_of_range& e) {
56613       {
56614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56615       };
56616     } catch (std::exception& e) {
56617       {
56618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56619       };
56620     } catch (...) {
56621       {
56622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56623       };
56624     }
56625   }
56626   jresult = (int)result;
56627   return jresult;
56628 }
56629
56630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56631   int jresult ;
56632   int result;
56633
56634   {
56635     try {
56636       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56637     } catch (std::out_of_range& e) {
56638       {
56639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56640       };
56641     } catch (std::exception& e) {
56642       {
56643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56644       };
56645     } catch (Dali::DaliException e) {
56646       {
56647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56648       };
56649     } catch (...) {
56650       {
56651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56652       };
56653     }
56654   }
56655
56656   jresult = (int)result;
56657   return jresult;
56658 }
56659
56660
56661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56662   int jresult ;
56663   int result;
56664
56665   {
56666     try {
56667       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56668     } catch (std::out_of_range& e) {
56669       {
56670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56671       };
56672     } catch (std::exception& e) {
56673       {
56674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56675       };
56676     } catch (Dali::DaliException e) {
56677       {
56678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56679       };
56680     } catch (...) {
56681       {
56682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56683       };
56684     }
56685   }
56686
56687   jresult = (int)result;
56688   return jresult;
56689 }
56690
56691
56692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56693   int jresult ;
56694   int result;
56695
56696   {
56697     try {
56698       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56699     } catch (std::out_of_range& e) {
56700       {
56701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56702       };
56703     } catch (std::exception& e) {
56704       {
56705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56706       };
56707     } catch (Dali::DaliException e) {
56708       {
56709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56710       };
56711     } catch (...) {
56712       {
56713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56714       };
56715     }
56716   }
56717
56718   jresult = (int)result;
56719   return jresult;
56720 }
56721
56722
56723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56724   int jresult ;
56725   int result;
56726
56727   {
56728     try {
56729       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56730     } catch (std::out_of_range& e) {
56731       {
56732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56733       };
56734     } catch (std::exception& e) {
56735       {
56736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56737       };
56738     } catch (Dali::DaliException e) {
56739       {
56740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56741       };
56742     } catch (...) {
56743       {
56744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56745       };
56746     }
56747   }
56748
56749   jresult = (int)result;
56750   return jresult;
56751 }
56752
56753
56754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56755   int jresult ;
56756   int result;
56757
56758   {
56759     try {
56760       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56761     } catch (std::out_of_range& e) {
56762       {
56763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56764       };
56765     } catch (std::exception& e) {
56766       {
56767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56768       };
56769     } catch (Dali::DaliException e) {
56770       {
56771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56772       };
56773     } catch (...) {
56774       {
56775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56776       };
56777     }
56778   }
56779
56780   jresult = (int)result;
56781   return jresult;
56782 }
56783
56784
56785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56786   int jresult ;
56787   int result;
56788
56789   {
56790     try {
56791       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56792     } catch (std::out_of_range& e) {
56793       {
56794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56795       };
56796     } catch (std::exception& e) {
56797       {
56798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56799       };
56800     } catch (Dali::DaliException e) {
56801       {
56802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56803       };
56804     } catch (...) {
56805       {
56806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56807       };
56808     }
56809   }
56810
56811   jresult = (int)result;
56812   return jresult;
56813 }
56814
56815
56816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56817   int jresult ;
56818   int result;
56819
56820   {
56821     try {
56822       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56823     } catch (std::out_of_range& e) {
56824       {
56825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56826       };
56827     } catch (std::exception& e) {
56828       {
56829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56830       };
56831     } catch (Dali::DaliException e) {
56832       {
56833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56834       };
56835     } catch (...) {
56836       {
56837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56838       };
56839     }
56840   }
56841
56842   jresult = (int)result;
56843   return jresult;
56844 }
56845
56846
56847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56848   int jresult ;
56849   int result;
56850
56851   {
56852     try {
56853       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56854     } catch (std::out_of_range& e) {
56855       {
56856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56857       };
56858     } catch (std::exception& e) {
56859       {
56860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56861       };
56862     } catch (Dali::DaliException e) {
56863       {
56864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56865       };
56866     } catch (...) {
56867       {
56868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56869       };
56870     }
56871   }
56872
56873   jresult = (int)result;
56874   return jresult;
56875 }
56876
56877
56878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56879   int jresult ;
56880   int result;
56881
56882   {
56883     try {
56884       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56885     } catch (std::out_of_range& e) {
56886       {
56887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56888       };
56889     } catch (std::exception& e) {
56890       {
56891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56892       };
56893     } catch (Dali::DaliException e) {
56894       {
56895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56896       };
56897     } catch (...) {
56898       {
56899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56900       };
56901     }
56902   }
56903
56904   jresult = (int)result;
56905   return jresult;
56906 }
56907
56908
56909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56910   int jresult ;
56911   int result;
56912
56913   {
56914     try {
56915       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56916     } catch (std::out_of_range& e) {
56917       {
56918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56919       };
56920     } catch (std::exception& e) {
56921       {
56922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56923       };
56924     } catch (Dali::DaliException e) {
56925       {
56926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56927       };
56928     } catch (...) {
56929       {
56930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56931       };
56932     }
56933   }
56934
56935   jresult = (int)result;
56936   return jresult;
56937 }
56938
56939
56940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56941   int jresult ;
56942   int result;
56943
56944   {
56945     try {
56946       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56947     } catch (std::out_of_range& e) {
56948       {
56949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56950       };
56951     } catch (std::exception& e) {
56952       {
56953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56954       };
56955     } catch (Dali::DaliException e) {
56956       {
56957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56958       };
56959     } catch (...) {
56960       {
56961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56962       };
56963     }
56964   }
56965
56966   jresult = (int)result;
56967   return jresult;
56968 }
56969
56970
56971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56972   int jresult ;
56973   int result;
56974
56975   {
56976     try {
56977       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56978     } catch (std::out_of_range& e) {
56979       {
56980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56981       };
56982     } catch (std::exception& e) {
56983       {
56984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56985       };
56986     } catch (Dali::DaliException e) {
56987       {
56988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56989       };
56990     } catch (...) {
56991       {
56992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56993       };
56994     }
56995   }
56996
56997   jresult = (int)result;
56998   return jresult;
56999 }
57000
57001
57002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57003   int jresult ;
57004   int result;
57005
57006   {
57007     try {
57008       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57009     } catch (std::out_of_range& e) {
57010       {
57011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57012       };
57013     } catch (std::exception& e) {
57014       {
57015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57016       };
57017     } catch (Dali::DaliException e) {
57018       {
57019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57020       };
57021     } catch (...) {
57022       {
57023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57024       };
57025     }
57026   }
57027
57028   jresult = (int)result;
57029   return jresult;
57030 }
57031
57032
57033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57034   int jresult ;
57035   int result;
57036
57037   {
57038     try {
57039       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57040     } catch (std::out_of_range& e) {
57041       {
57042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57043       };
57044     } catch (std::exception& e) {
57045       {
57046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57047       };
57048     } catch (Dali::DaliException e) {
57049       {
57050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57051       };
57052     } catch (...) {
57053       {
57054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57055       };
57056     }
57057   }
57058
57059   jresult = (int)result;
57060   return jresult;
57061 }
57062
57063
57064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57065   int jresult ;
57066   int result;
57067
57068   {
57069     try {
57070       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57071     } catch (std::out_of_range& e) {
57072       {
57073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57074       };
57075     } catch (std::exception& e) {
57076       {
57077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57078       };
57079     } catch (Dali::DaliException e) {
57080       {
57081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57082       };
57083     } catch (...) {
57084       {
57085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57086       };
57087     }
57088   }
57089
57090   jresult = (int)result;
57091   return jresult;
57092 }
57093
57094
57095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57096   int jresult ;
57097   int result;
57098
57099   {
57100     try {
57101       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57102     } catch (std::out_of_range& e) {
57103       {
57104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57105       };
57106     } catch (std::exception& e) {
57107       {
57108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57109       };
57110     } catch (Dali::DaliException e) {
57111       {
57112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57113       };
57114     } catch (...) {
57115       {
57116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57117       };
57118     }
57119   }
57120
57121   jresult = (int)result;
57122   return jresult;
57123 }
57124
57125
57126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57127   int jresult ;
57128   int result;
57129
57130   {
57131     try {
57132       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57133     } catch (std::out_of_range& e) {
57134       {
57135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57136       };
57137     } catch (std::exception& e) {
57138       {
57139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57140       };
57141     } catch (Dali::DaliException e) {
57142       {
57143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57144       };
57145     } catch (...) {
57146       {
57147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57148       };
57149     }
57150   }
57151
57152   jresult = (int)result;
57153   return jresult;
57154 }
57155
57156
57157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57158   int jresult ;
57159   int result;
57160
57161   {
57162     try {
57163       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57164     } catch (std::out_of_range& e) {
57165       {
57166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57167       };
57168     } catch (std::exception& e) {
57169       {
57170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57171       };
57172     } catch (Dali::DaliException e) {
57173       {
57174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57175       };
57176     } catch (...) {
57177       {
57178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57179       };
57180     }
57181   }
57182
57183   jresult = (int)result;
57184   return jresult;
57185 }
57186
57187
57188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57189   int jresult ;
57190   int result;
57191
57192   {
57193     try {
57194       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57195     } catch (std::out_of_range& e) {
57196       {
57197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57198       };
57199     } catch (std::exception& e) {
57200       {
57201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57202       };
57203     } catch (Dali::DaliException e) {
57204       {
57205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57206       };
57207     } catch (...) {
57208       {
57209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57210       };
57211     }
57212   }
57213
57214   jresult = (int)result;
57215   return jresult;
57216 }
57217
57218
57219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57220   int jresult ;
57221   int result;
57222
57223   {
57224     try {
57225       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57226     } catch (std::out_of_range& e) {
57227       {
57228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57229       };
57230     } catch (std::exception& e) {
57231       {
57232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57233       };
57234     } catch (Dali::DaliException e) {
57235       {
57236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57237       };
57238     } catch (...) {
57239       {
57240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57241       };
57242     }
57243   }
57244
57245   jresult = (int)result;
57246   return jresult;
57247 }
57248
57249
57250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57251   int jresult ;
57252   int result;
57253
57254   {
57255     try {
57256       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57257     } catch (std::out_of_range& e) {
57258       {
57259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57260       };
57261     } catch (std::exception& e) {
57262       {
57263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57264       };
57265     } catch (Dali::DaliException e) {
57266       {
57267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57268       };
57269     } catch (...) {
57270       {
57271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57272       };
57273     }
57274   }
57275
57276   jresult = (int)result;
57277   return jresult;
57278 }
57279
57280
57281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57282   int jresult ;
57283   int result;
57284
57285   {
57286     try {
57287       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57288     } catch (std::out_of_range& e) {
57289       {
57290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57291       };
57292     } catch (std::exception& e) {
57293       {
57294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57295       };
57296     } catch (Dali::DaliException e) {
57297       {
57298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57299       };
57300     } catch (...) {
57301       {
57302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57303       };
57304     }
57305   }
57306
57307   jresult = (int)result;
57308   return jresult;
57309 }
57310
57311
57312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57313   int jresult ;
57314   int result;
57315
57316   {
57317     try {
57318       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57319     } catch (std::out_of_range& e) {
57320       {
57321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57322       };
57323     } catch (std::exception& e) {
57324       {
57325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57326       };
57327     } catch (Dali::DaliException e) {
57328       {
57329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57330       };
57331     } catch (...) {
57332       {
57333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57334       };
57335     }
57336   }
57337
57338   jresult = (int)result;
57339   return jresult;
57340 }
57341
57342
57343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57344   int jresult ;
57345   int result;
57346
57347   {
57348     try {
57349       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57350     } catch (std::out_of_range& e) {
57351       {
57352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57353       };
57354     } catch (std::exception& e) {
57355       {
57356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57357       };
57358     } catch (Dali::DaliException e) {
57359       {
57360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57361       };
57362     } catch (...) {
57363       {
57364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57365       };
57366     }
57367   }
57368
57369   jresult = (int)result;
57370   return jresult;
57371 }
57372
57373
57374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57375   int jresult ;
57376   int result;
57377
57378   {
57379     try {
57380       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57381     } catch (std::out_of_range& e) {
57382       {
57383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57384       };
57385     } catch (std::exception& e) {
57386       {
57387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57388       };
57389     } catch (Dali::DaliException e) {
57390       {
57391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57392       };
57393     } catch (...) {
57394       {
57395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57396       };
57397     }
57398   }
57399
57400   jresult = (int)result;
57401   return jresult;
57402 }
57403
57404
57405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57406   int jresult ;
57407   int result;
57408
57409   {
57410     try {
57411       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57412     } catch (std::out_of_range& e) {
57413       {
57414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57415       };
57416     } catch (std::exception& e) {
57417       {
57418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57419       };
57420     } catch (Dali::DaliException e) {
57421       {
57422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57423       };
57424     } catch (...) {
57425       {
57426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57427       };
57428     }
57429   }
57430
57431   jresult = (int)result;
57432   return jresult;
57433 }
57434
57435
57436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57437   int jresult ;
57438   int result;
57439
57440   {
57441     try {
57442       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57443     } catch (std::out_of_range& e) {
57444       {
57445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57446       };
57447     } catch (std::exception& e) {
57448       {
57449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57450       };
57451     } catch (Dali::DaliException e) {
57452       {
57453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57454       };
57455     } catch (...) {
57456       {
57457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57458       };
57459     }
57460   }
57461
57462   jresult = (int)result;
57463   return jresult;
57464 }
57465
57466
57467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57468   int jresult ;
57469   int result;
57470
57471   {
57472     try {
57473       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57474     } catch (std::out_of_range& e) {
57475       {
57476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57477       };
57478     } catch (std::exception& e) {
57479       {
57480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57481       };
57482     } catch (Dali::DaliException e) {
57483       {
57484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57485       };
57486     } catch (...) {
57487       {
57488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57489       };
57490     }
57491   }
57492
57493   jresult = (int)result;
57494   return jresult;
57495 }
57496
57497
57498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57499   void * jresult ;
57500   Dali::Toolkit::Builder *result = 0 ;
57501
57502   {
57503     try {
57504       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57505     } catch (std::out_of_range& e) {
57506       {
57507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57508       };
57509     } catch (std::exception& e) {
57510       {
57511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57512       };
57513     } catch (Dali::DaliException e) {
57514       {
57515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57516       };
57517     } catch (...) {
57518       {
57519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57520       };
57521     }
57522   }
57523
57524   jresult = (void *)result;
57525   return jresult;
57526 }
57527
57528
57529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57530   void * jresult ;
57531   Dali::Toolkit::Builder result;
57532
57533   {
57534     try {
57535       result = Dali::Toolkit::Builder::New();
57536     } catch (std::out_of_range& e) {
57537       {
57538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57539       };
57540     } catch (std::exception& e) {
57541       {
57542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57543       };
57544     } catch (Dali::DaliException e) {
57545       {
57546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57547       };
57548     } catch (...) {
57549       {
57550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57551       };
57552     }
57553   }
57554
57555   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57556   return jresult;
57557 }
57558
57559
57560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57561   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57562
57563   arg1 = (Dali::Toolkit::Builder *)jarg1;
57564   {
57565     try {
57566       delete arg1;
57567     } catch (std::out_of_range& e) {
57568       {
57569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57570       };
57571     } catch (std::exception& e) {
57572       {
57573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57574       };
57575     } catch (Dali::DaliException e) {
57576       {
57577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57578       };
57579     } catch (...) {
57580       {
57581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57582       };
57583     }
57584   }
57585
57586 }
57587
57588
57589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57590   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57591   std::string *arg2 = 0 ;
57592   Dali::Toolkit::Builder::UIFormat arg3 ;
57593
57594   arg1 = (Dali::Toolkit::Builder *)jarg1;
57595   if (!jarg2) {
57596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57597     return ;
57598   }
57599   std::string arg2_str(jarg2);
57600   arg2 = &arg2_str;
57601   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57602   {
57603     try {
57604       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57605     } catch (std::out_of_range& e) {
57606       {
57607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57608       };
57609     } catch (std::exception& e) {
57610       {
57611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57612       };
57613     } catch (Dali::DaliException e) {
57614       {
57615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57616       };
57617     } catch (...) {
57618       {
57619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57620       };
57621     }
57622   }
57623
57624
57625   //argout typemap for const std::string&
57626
57627 }
57628
57629
57630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57631   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57632   std::string *arg2 = 0 ;
57633
57634   arg1 = (Dali::Toolkit::Builder *)jarg1;
57635   if (!jarg2) {
57636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57637     return ;
57638   }
57639   std::string arg2_str(jarg2);
57640   arg2 = &arg2_str;
57641   {
57642     try {
57643       (arg1)->LoadFromString((std::string const &)*arg2);
57644     } catch (std::out_of_range& e) {
57645       {
57646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57647       };
57648     } catch (std::exception& e) {
57649       {
57650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57651       };
57652     } catch (Dali::DaliException e) {
57653       {
57654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57655       };
57656     } catch (...) {
57657       {
57658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57659       };
57660     }
57661   }
57662
57663
57664   //argout typemap for const std::string&
57665
57666 }
57667
57668
57669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57670   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57671   Dali::Property::Map *arg2 = 0 ;
57672
57673   arg1 = (Dali::Toolkit::Builder *)jarg1;
57674   arg2 = (Dali::Property::Map *)jarg2;
57675   if (!arg2) {
57676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57677     return ;
57678   }
57679   {
57680     try {
57681       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57682     } catch (std::out_of_range& e) {
57683       {
57684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57685       };
57686     } catch (std::exception& e) {
57687       {
57688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57689       };
57690     } catch (Dali::DaliException e) {
57691       {
57692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57693       };
57694     } catch (...) {
57695       {
57696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57697       };
57698     }
57699   }
57700
57701 }
57702
57703
57704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57705   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57706   std::string *arg2 = 0 ;
57707   Dali::Property::Value *arg3 = 0 ;
57708
57709   arg1 = (Dali::Toolkit::Builder *)jarg1;
57710   if (!jarg2) {
57711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57712     return ;
57713   }
57714   std::string arg2_str(jarg2);
57715   arg2 = &arg2_str;
57716   arg3 = (Dali::Property::Value *)jarg3;
57717   if (!arg3) {
57718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57719     return ;
57720   }
57721   {
57722     try {
57723       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57724     } catch (std::out_of_range& e) {
57725       {
57726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57727       };
57728     } catch (std::exception& e) {
57729       {
57730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57731       };
57732     } catch (Dali::DaliException e) {
57733       {
57734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57735       };
57736     } catch (...) {
57737       {
57738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57739       };
57740     }
57741   }
57742
57743
57744   //argout typemap for const std::string&
57745
57746 }
57747
57748
57749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57750   void * jresult ;
57751   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57752   Dali::Property::Map *result = 0 ;
57753
57754   arg1 = (Dali::Toolkit::Builder *)jarg1;
57755   {
57756     try {
57757       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57758     } catch (std::out_of_range& e) {
57759       {
57760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57761       };
57762     } catch (std::exception& e) {
57763       {
57764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57765       };
57766     } catch (Dali::DaliException e) {
57767       {
57768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57769       };
57770     } catch (...) {
57771       {
57772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57773       };
57774     }
57775   }
57776
57777   jresult = (void *)result;
57778   return jresult;
57779 }
57780
57781
57782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57783   void * jresult ;
57784   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57785   std::string *arg2 = 0 ;
57786   Dali::Property::Value *result = 0 ;
57787
57788   arg1 = (Dali::Toolkit::Builder *)jarg1;
57789   if (!jarg2) {
57790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57791     return 0;
57792   }
57793   std::string arg2_str(jarg2);
57794   arg2 = &arg2_str;
57795   {
57796     try {
57797       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57798     } catch (std::out_of_range& e) {
57799       {
57800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57801       };
57802     } catch (std::exception& e) {
57803       {
57804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57805       };
57806     } catch (Dali::DaliException e) {
57807       {
57808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57809       };
57810     } catch (...) {
57811       {
57812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57813       };
57814     }
57815   }
57816
57817   jresult = (void *)result;
57818
57819   //argout typemap for const std::string&
57820
57821   return jresult;
57822 }
57823
57824
57825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57826   void * jresult ;
57827   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57828   std::string *arg2 = 0 ;
57829   Dali::Animation result;
57830
57831   arg1 = (Dali::Toolkit::Builder *)jarg1;
57832   if (!jarg2) {
57833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57834     return 0;
57835   }
57836   std::string arg2_str(jarg2);
57837   arg2 = &arg2_str;
57838   {
57839     try {
57840       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57841     } catch (std::out_of_range& e) {
57842       {
57843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57844       };
57845     } catch (std::exception& e) {
57846       {
57847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57848       };
57849     } catch (Dali::DaliException e) {
57850       {
57851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57852       };
57853     } catch (...) {
57854       {
57855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57856       };
57857     }
57858   }
57859
57860   jresult = new Dali::Animation((const Dali::Animation &)result);
57861
57862   //argout typemap for const std::string&
57863
57864   return jresult;
57865 }
57866
57867
57868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57869   void * jresult ;
57870   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57871   std::string *arg2 = 0 ;
57872   Dali::Property::Map *arg3 = 0 ;
57873   Dali::Animation result;
57874
57875   arg1 = (Dali::Toolkit::Builder *)jarg1;
57876   if (!jarg2) {
57877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57878     return 0;
57879   }
57880   std::string arg2_str(jarg2);
57881   arg2 = &arg2_str;
57882   arg3 = (Dali::Property::Map *)jarg3;
57883   if (!arg3) {
57884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57885     return 0;
57886   }
57887   {
57888     try {
57889       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57890     } catch (std::out_of_range& e) {
57891       {
57892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57893       };
57894     } catch (std::exception& e) {
57895       {
57896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57897       };
57898     } catch (Dali::DaliException e) {
57899       {
57900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57901       };
57902     } catch (...) {
57903       {
57904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57905       };
57906     }
57907   }
57908
57909   jresult = new Dali::Animation((const Dali::Animation &)result);
57910
57911   //argout typemap for const std::string&
57912
57913   return jresult;
57914 }
57915
57916
57917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57918   void * jresult ;
57919   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57920   std::string *arg2 = 0 ;
57921   Dali::Actor arg3 ;
57922   Dali::Actor *argp3 ;
57923   Dali::Animation result;
57924
57925   arg1 = (Dali::Toolkit::Builder *)jarg1;
57926   if (!jarg2) {
57927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57928     return 0;
57929   }
57930   std::string arg2_str(jarg2);
57931   arg2 = &arg2_str;
57932   argp3 = (Dali::Actor *)jarg3;
57933   if (!argp3) {
57934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57935     return 0;
57936   }
57937   arg3 = *argp3;
57938   {
57939     try {
57940       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57941     } catch (std::out_of_range& e) {
57942       {
57943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57944       };
57945     } catch (std::exception& e) {
57946       {
57947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57948       };
57949     } catch (Dali::DaliException e) {
57950       {
57951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57952       };
57953     } catch (...) {
57954       {
57955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57956       };
57957     }
57958   }
57959
57960   jresult = new Dali::Animation((const Dali::Animation &)result);
57961
57962   //argout typemap for const std::string&
57963
57964   return jresult;
57965 }
57966
57967
57968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57969   void * jresult ;
57970   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57971   std::string *arg2 = 0 ;
57972   Dali::Property::Map *arg3 = 0 ;
57973   Dali::Actor arg4 ;
57974   Dali::Actor *argp4 ;
57975   Dali::Animation result;
57976
57977   arg1 = (Dali::Toolkit::Builder *)jarg1;
57978   if (!jarg2) {
57979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57980     return 0;
57981   }
57982   std::string arg2_str(jarg2);
57983   arg2 = &arg2_str;
57984   arg3 = (Dali::Property::Map *)jarg3;
57985   if (!arg3) {
57986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57987     return 0;
57988   }
57989   argp4 = (Dali::Actor *)jarg4;
57990   if (!argp4) {
57991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57992     return 0;
57993   }
57994   arg4 = *argp4;
57995   {
57996     try {
57997       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57998     } catch (std::out_of_range& e) {
57999       {
58000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58001       };
58002     } catch (std::exception& e) {
58003       {
58004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58005       };
58006     } catch (Dali::DaliException e) {
58007       {
58008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58009       };
58010     } catch (...) {
58011       {
58012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58013       };
58014     }
58015   }
58016
58017   jresult = new Dali::Animation((const Dali::Animation &)result);
58018
58019   //argout typemap for const std::string&
58020
58021   return jresult;
58022 }
58023
58024
58025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58026   void * jresult ;
58027   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58028   std::string *arg2 = 0 ;
58029   Dali::BaseHandle result;
58030
58031   arg1 = (Dali::Toolkit::Builder *)jarg1;
58032   if (!jarg2) {
58033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58034     return 0;
58035   }
58036   std::string arg2_str(jarg2);
58037   arg2 = &arg2_str;
58038   {
58039     try {
58040       result = (arg1)->Create((std::string const &)*arg2);
58041     } catch (std::out_of_range& e) {
58042       {
58043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58044       };
58045     } catch (std::exception& e) {
58046       {
58047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58048       };
58049     } catch (Dali::DaliException e) {
58050       {
58051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58052       };
58053     } catch (...) {
58054       {
58055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58056       };
58057     }
58058   }
58059
58060   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58061
58062   //argout typemap for const std::string&
58063
58064   return jresult;
58065 }
58066
58067
58068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58069   void * jresult ;
58070   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58071   std::string *arg2 = 0 ;
58072   Dali::Property::Map *arg3 = 0 ;
58073   Dali::BaseHandle result;
58074
58075   arg1 = (Dali::Toolkit::Builder *)jarg1;
58076   if (!jarg2) {
58077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58078     return 0;
58079   }
58080   std::string arg2_str(jarg2);
58081   arg2 = &arg2_str;
58082   arg3 = (Dali::Property::Map *)jarg3;
58083   if (!arg3) {
58084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58085     return 0;
58086   }
58087   {
58088     try {
58089       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58090     } catch (std::out_of_range& e) {
58091       {
58092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58093       };
58094     } catch (std::exception& e) {
58095       {
58096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58097       };
58098     } catch (Dali::DaliException e) {
58099       {
58100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58101       };
58102     } catch (...) {
58103       {
58104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58105       };
58106     }
58107   }
58108
58109   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58110
58111   //argout typemap for const std::string&
58112
58113   return jresult;
58114 }
58115
58116
58117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58118   void * jresult ;
58119   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58120   std::string *arg2 = 0 ;
58121   Dali::BaseHandle result;
58122
58123   arg1 = (Dali::Toolkit::Builder *)jarg1;
58124   if (!jarg2) {
58125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58126     return 0;
58127   }
58128   std::string arg2_str(jarg2);
58129   arg2 = &arg2_str;
58130   {
58131     try {
58132       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58133     } catch (std::out_of_range& e) {
58134       {
58135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58136       };
58137     } catch (std::exception& e) {
58138       {
58139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58140       };
58141     } catch (Dali::DaliException e) {
58142       {
58143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58144       };
58145     } catch (...) {
58146       {
58147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58148       };
58149     }
58150   }
58151
58152   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58153
58154   //argout typemap for const std::string&
58155
58156   return jresult;
58157 }
58158
58159
58160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58161   unsigned int jresult ;
58162   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58163   std::string *arg2 = 0 ;
58164   Dali::Handle *arg3 = 0 ;
58165   bool result;
58166
58167   arg1 = (Dali::Toolkit::Builder *)jarg1;
58168   if (!jarg2) {
58169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58170     return 0;
58171   }
58172   std::string arg2_str(jarg2);
58173   arg2 = &arg2_str;
58174   arg3 = (Dali::Handle *)jarg3;
58175   if (!arg3) {
58176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58177     return 0;
58178   }
58179   {
58180     try {
58181       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58182     } catch (std::out_of_range& e) {
58183       {
58184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58185       };
58186     } catch (std::exception& e) {
58187       {
58188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58189       };
58190     } catch (Dali::DaliException e) {
58191       {
58192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58193       };
58194     } catch (...) {
58195       {
58196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58197       };
58198     }
58199   }
58200
58201   jresult = result;
58202
58203   //argout typemap for const std::string&
58204
58205   return jresult;
58206 }
58207
58208
58209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58210   unsigned int jresult ;
58211   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58212   Dali::Handle *arg2 = 0 ;
58213   std::string *arg3 = 0 ;
58214   bool result;
58215
58216   arg1 = (Dali::Toolkit::Builder *)jarg1;
58217   arg2 = (Dali::Handle *)jarg2;
58218   if (!arg2) {
58219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58220     return 0;
58221   }
58222   if (!jarg3) {
58223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58224     return 0;
58225   }
58226   std::string arg3_str(jarg3);
58227   arg3 = &arg3_str;
58228   {
58229     try {
58230       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58231     } catch (std::out_of_range& e) {
58232       {
58233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58234       };
58235     } catch (std::exception& e) {
58236       {
58237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58238       };
58239     } catch (Dali::DaliException e) {
58240       {
58241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58242       };
58243     } catch (...) {
58244       {
58245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58246       };
58247     }
58248   }
58249
58250   jresult = result;
58251
58252   //argout typemap for const std::string&
58253
58254   return jresult;
58255 }
58256
58257
58258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58259   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58260   Dali::Actor arg2 ;
58261   Dali::Actor *argp2 ;
58262
58263   arg1 = (Dali::Toolkit::Builder *)jarg1;
58264   argp2 = (Dali::Actor *)jarg2;
58265   if (!argp2) {
58266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58267     return ;
58268   }
58269   arg2 = *argp2;
58270   {
58271     try {
58272       (arg1)->AddActors(arg2);
58273     } catch (std::out_of_range& e) {
58274       {
58275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58276       };
58277     } catch (std::exception& e) {
58278       {
58279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58280       };
58281     } catch (Dali::DaliException e) {
58282       {
58283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58284       };
58285     } catch (...) {
58286       {
58287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58288       };
58289     }
58290   }
58291
58292 }
58293
58294
58295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58296   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58297   std::string *arg2 = 0 ;
58298   Dali::Actor arg3 ;
58299   Dali::Actor *argp3 ;
58300
58301   arg1 = (Dali::Toolkit::Builder *)jarg1;
58302   if (!jarg2) {
58303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58304     return ;
58305   }
58306   std::string arg2_str(jarg2);
58307   arg2 = &arg2_str;
58308   argp3 = (Dali::Actor *)jarg3;
58309   if (!argp3) {
58310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58311     return ;
58312   }
58313   arg3 = *argp3;
58314   {
58315     try {
58316       (arg1)->AddActors((std::string const &)*arg2,arg3);
58317     } catch (std::out_of_range& e) {
58318       {
58319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58320       };
58321     } catch (std::exception& e) {
58322       {
58323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58324       };
58325     } catch (Dali::DaliException e) {
58326       {
58327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58328       };
58329     } catch (...) {
58330       {
58331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58332       };
58333     }
58334   }
58335
58336
58337   //argout typemap for const std::string&
58338
58339 }
58340
58341
58342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58343   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58344   std::string *arg2 = 0 ;
58345
58346   arg1 = (Dali::Toolkit::Builder *)jarg1;
58347   if (!jarg2) {
58348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58349     return ;
58350   }
58351   std::string arg2_str(jarg2);
58352   arg2 = &arg2_str;
58353   {
58354     try {
58355       (arg1)->CreateRenderTask((std::string const &)*arg2);
58356     } catch (std::out_of_range& e) {
58357       {
58358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58359       };
58360     } catch (std::exception& e) {
58361       {
58362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58363       };
58364     } catch (Dali::DaliException e) {
58365       {
58366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58367       };
58368     } catch (...) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58371       };
58372     }
58373   }
58374
58375
58376   //argout typemap for const std::string&
58377
58378 }
58379
58380
58381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58382   void * jresult ;
58383   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58384   std::string *arg2 = 0 ;
58385   Dali::Path result;
58386
58387   arg1 = (Dali::Toolkit::Builder *)jarg1;
58388   if (!jarg2) {
58389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58390     return 0;
58391   }
58392   std::string arg2_str(jarg2);
58393   arg2 = &arg2_str;
58394   {
58395     try {
58396       result = (arg1)->GetPath((std::string const &)*arg2);
58397     } catch (std::out_of_range& e) {
58398       {
58399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58400       };
58401     } catch (std::exception& e) {
58402       {
58403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58404       };
58405     } catch (Dali::DaliException e) {
58406       {
58407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58408       };
58409     } catch (...) {
58410       {
58411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58412       };
58413     }
58414   }
58415
58416   jresult = new Dali::Path((const Dali::Path &)result);
58417
58418   //argout typemap for const std::string&
58419
58420   return jresult;
58421 }
58422
58423
58424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58425   void * jresult ;
58426   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58427   std::string *arg2 = 0 ;
58428   Dali::PathConstrainer result;
58429
58430   arg1 = (Dali::Toolkit::Builder *)jarg1;
58431   if (!jarg2) {
58432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58433     return 0;
58434   }
58435   std::string arg2_str(jarg2);
58436   arg2 = &arg2_str;
58437   {
58438     try {
58439       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58440     } catch (std::out_of_range& e) {
58441       {
58442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58443       };
58444     } catch (std::exception& e) {
58445       {
58446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58447       };
58448     } catch (Dali::DaliException e) {
58449       {
58450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58451       };
58452     } catch (...) {
58453       {
58454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58455       };
58456     }
58457   }
58458
58459   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58460
58461   //argout typemap for const std::string&
58462
58463   return jresult;
58464 }
58465
58466
58467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58468   void * jresult ;
58469   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58470   std::string *arg2 = 0 ;
58471   Dali::LinearConstrainer result;
58472
58473   arg1 = (Dali::Toolkit::Builder *)jarg1;
58474   if (!jarg2) {
58475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58476     return 0;
58477   }
58478   std::string arg2_str(jarg2);
58479   arg2 = &arg2_str;
58480   {
58481     try {
58482       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58483     } catch (std::out_of_range& e) {
58484       {
58485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58486       };
58487     } catch (std::exception& e) {
58488       {
58489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58490       };
58491     } catch (Dali::DaliException e) {
58492       {
58493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58494       };
58495     } catch (...) {
58496       {
58497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58498       };
58499     }
58500   }
58501
58502   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58503
58504   //argout typemap for const std::string&
58505
58506   return jresult;
58507 }
58508
58509
58510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58511   void * jresult ;
58512   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58513   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58514
58515   arg1 = (Dali::Toolkit::Builder *)jarg1;
58516   {
58517     try {
58518       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58519     } catch (std::out_of_range& e) {
58520       {
58521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58522       };
58523     } catch (std::exception& e) {
58524       {
58525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58526       };
58527     } catch (Dali::DaliException e) {
58528       {
58529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58530       };
58531     } catch (...) {
58532       {
58533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58534       };
58535     }
58536   }
58537
58538   jresult = (void *)result;
58539   return jresult;
58540 }
58541
58542
58543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58544   void * jresult ;
58545   Dali::Toolkit::TransitionData *result = 0 ;
58546
58547   {
58548     try {
58549       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58550     } catch (std::out_of_range& e) {
58551       {
58552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58553       };
58554     } catch (std::exception& e) {
58555       {
58556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58557       };
58558     } catch (Dali::DaliException e) {
58559       {
58560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58561       };
58562     } catch (...) {
58563       {
58564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58565       };
58566     }
58567   }
58568
58569   jresult = (void *)result;
58570   return jresult;
58571 }
58572
58573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58574   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58575
58576   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58577   {
58578     try {
58579       delete arg1;
58580     } catch (std::out_of_range& e) {
58581       {
58582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58583       };
58584     } catch (std::exception& e) {
58585       {
58586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58587       };
58588     } catch (Dali::DaliException e) {
58589       {
58590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58591       };
58592     } catch (...) {
58593       {
58594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58595       };
58596     }
58597   }
58598
58599 }
58600
58601
58602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58603   void * jresult ;
58604   Dali::Property::Map *arg1 = 0 ;
58605   Dali::Toolkit::TransitionData result;
58606
58607   arg1 = (Dali::Property::Map *)jarg1;
58608   if (!arg1) {
58609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58610     return 0;
58611   }
58612   {
58613     try {
58614       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58615     } catch (std::out_of_range& e) {
58616       {
58617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58618       };
58619     } catch (std::exception& e) {
58620       {
58621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58622       };
58623     } catch (Dali::DaliException e) {
58624       {
58625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58626       };
58627     } catch (...) {
58628       {
58629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58630       };
58631     }
58632   }
58633
58634   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58635   return jresult;
58636 }
58637
58638
58639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58640   void * jresult ;
58641   Dali::Property::Array *arg1 = 0 ;
58642   Dali::Toolkit::TransitionData result;
58643
58644   arg1 = (Dali::Property::Array *)jarg1;
58645   if (!arg1) {
58646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58647     return 0;
58648   }
58649   {
58650     try {
58651       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58652     } catch (std::out_of_range& e) {
58653       {
58654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58655       };
58656     } catch (std::exception& e) {
58657       {
58658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58659       };
58660     } catch (Dali::DaliException e) {
58661       {
58662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58663       };
58664     } catch (...) {
58665       {
58666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58667       };
58668     }
58669   }
58670
58671   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58672   return jresult;
58673 }
58674
58675
58676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58677   void * jresult ;
58678   Dali::BaseHandle arg1 ;
58679   Dali::BaseHandle *argp1 ;
58680   Dali::Toolkit::TransitionData result;
58681
58682   argp1 = (Dali::BaseHandle *)jarg1;
58683   if (!argp1) {
58684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58685     return 0;
58686   }
58687   arg1 = *argp1;
58688   {
58689     try {
58690       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58691     } catch (std::out_of_range& e) {
58692       {
58693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58694       };
58695     } catch (std::exception& e) {
58696       {
58697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58698       };
58699     } catch (Dali::DaliException e) {
58700       {
58701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58702       };
58703     } catch (...) {
58704       {
58705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58706       };
58707     }
58708   }
58709
58710   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58711   return jresult;
58712 }
58713
58714
58715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58716   void * jresult ;
58717   Dali::Toolkit::TransitionData *arg1 = 0 ;
58718   Dali::Toolkit::TransitionData *result = 0 ;
58719
58720   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58721   if (!arg1) {
58722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58723     return 0;
58724   }
58725   {
58726     try {
58727       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58728     } catch (std::out_of_range& e) {
58729       {
58730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58731       };
58732     } catch (std::exception& e) {
58733       {
58734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58735       };
58736     } catch (Dali::DaliException e) {
58737       {
58738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58739       };
58740     } catch (...) {
58741       {
58742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58743       };
58744     }
58745   }
58746
58747   jresult = (void *)result;
58748   return jresult;
58749 }
58750
58751
58752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58753   void * jresult ;
58754   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58755   Dali::Toolkit::TransitionData *arg2 = 0 ;
58756   Dali::Toolkit::TransitionData *result = 0 ;
58757
58758   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58759   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58760   if (!arg2) {
58761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58762     return 0;
58763   }
58764   {
58765     try {
58766       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58767     } catch (std::out_of_range& e) {
58768       {
58769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58770       };
58771     } catch (std::exception& e) {
58772       {
58773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58774       };
58775     } catch (Dali::DaliException e) {
58776       {
58777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58778       };
58779     } catch (...) {
58780       {
58781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58782       };
58783     }
58784   }
58785
58786   jresult = (void *)result;
58787   return jresult;
58788 }
58789
58790
58791 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58792   unsigned long jresult ;
58793   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58794   size_t result;
58795
58796   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58797   {
58798     try {
58799       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58800     } catch (std::out_of_range& e) {
58801       {
58802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58803       };
58804     } catch (std::exception& e) {
58805       {
58806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58807       };
58808     } catch (Dali::DaliException e) {
58809       {
58810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58811       };
58812     } catch (...) {
58813       {
58814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58815       };
58816     }
58817   }
58818
58819   jresult = (unsigned long)result;
58820   return jresult;
58821 }
58822
58823
58824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58825   void * jresult ;
58826   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58827   size_t arg2 ;
58828   Dali::Property::Map result;
58829
58830   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58831   arg2 = (size_t)jarg2;
58832   {
58833     try {
58834       result = (arg1)->GetAnimatorAt(arg2);
58835     } catch (std::out_of_range& e) {
58836       {
58837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58838       };
58839     } catch (std::exception& e) {
58840       {
58841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58842       };
58843     } catch (Dali::DaliException e) {
58844       {
58845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58846       };
58847     } catch (...) {
58848       {
58849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58850       };
58851     }
58852   }
58853
58854   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58855   return jresult;
58856 }
58857
58858
58859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58860   int jresult ;
58861   int result;
58862
58863   {
58864     try {
58865       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58866     } catch (std::out_of_range& e) {
58867       {
58868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58869       };
58870     } catch (std::exception& e) {
58871       {
58872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58873       };
58874     } catch (Dali::DaliException e) {
58875       {
58876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58877       };
58878     } catch (...) {
58879       {
58880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58881       };
58882     }
58883   }
58884
58885   jresult = (int)result;
58886   return jresult;
58887 }
58888
58889
58890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58891   int jresult ;
58892   int result;
58893
58894   {
58895     try {
58896       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58897     } catch (std::out_of_range& e) {
58898       {
58899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58900       };
58901     } catch (std::exception& e) {
58902       {
58903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58904       };
58905     } catch (Dali::DaliException e) {
58906       {
58907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58908       };
58909     } catch (...) {
58910       {
58911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58912       };
58913     }
58914   }
58915
58916   jresult = (int)result;
58917   return jresult;
58918 }
58919
58920
58921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58922   int jresult ;
58923   int result;
58924
58925   {
58926     try {
58927       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58928     } catch (std::out_of_range& e) {
58929       {
58930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58931       };
58932     } catch (std::exception& e) {
58933       {
58934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58935       };
58936     } catch (Dali::DaliException e) {
58937       {
58938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58939       };
58940     } catch (...) {
58941       {
58942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58943       };
58944     }
58945   }
58946
58947   jresult = (int)result;
58948   return jresult;
58949 }
58950
58951
58952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58953   int jresult ;
58954   int result;
58955
58956   {
58957     try {
58958       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58959     } catch (std::out_of_range& e) {
58960       {
58961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58962       };
58963     } catch (std::exception& e) {
58964       {
58965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58966       };
58967     } catch (Dali::DaliException e) {
58968       {
58969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58970       };
58971     } catch (...) {
58972       {
58973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58974       };
58975     }
58976   }
58977
58978   jresult = (int)result;
58979   return jresult;
58980 }
58981
58982
58983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58984   int jresult ;
58985   int result;
58986
58987   {
58988     try {
58989       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58990     } catch (std::out_of_range& e) {
58991       {
58992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58993       };
58994     } catch (std::exception& e) {
58995       {
58996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58997       };
58998     } catch (Dali::DaliException e) {
58999       {
59000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59001       };
59002     } catch (...) {
59003       {
59004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59005       };
59006     }
59007   }
59008
59009   jresult = (int)result;
59010   return jresult;
59011 }
59012
59013
59014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59015   int jresult ;
59016   int result;
59017
59018   {
59019     try {
59020       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59021     } catch (std::out_of_range& e) {
59022       {
59023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59024       };
59025     } catch (std::exception& e) {
59026       {
59027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59028       };
59029     } catch (Dali::DaliException e) {
59030       {
59031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59032       };
59033     } catch (...) {
59034       {
59035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59036       };
59037     }
59038   }
59039
59040   jresult = (int)result;
59041   return jresult;
59042 }
59043
59044
59045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59046   int jresult ;
59047   int result;
59048
59049   {
59050     try {
59051       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59052     } catch (std::out_of_range& e) {
59053       {
59054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59055       };
59056     } catch (std::exception& e) {
59057       {
59058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59059       };
59060     } catch (Dali::DaliException e) {
59061       {
59062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59063       };
59064     } catch (...) {
59065       {
59066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59067       };
59068     }
59069   }
59070
59071   jresult = (int)result;
59072   return jresult;
59073 }
59074
59075
59076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59077   int jresult ;
59078   int result;
59079
59080   {
59081     try {
59082       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59083     } catch (std::out_of_range& e) {
59084       {
59085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59086       };
59087     } catch (std::exception& e) {
59088       {
59089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59090       };
59091     } catch (Dali::DaliException e) {
59092       {
59093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59094       };
59095     } catch (...) {
59096       {
59097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59098       };
59099     }
59100   }
59101
59102   jresult = (int)result;
59103   return jresult;
59104 }
59105
59106
59107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59108   int jresult ;
59109   int result;
59110
59111   {
59112     try {
59113       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59114     } catch (std::out_of_range& e) {
59115       {
59116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59117       };
59118     } catch (std::exception& e) {
59119       {
59120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59121       };
59122     } catch (Dali::DaliException e) {
59123       {
59124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59125       };
59126     } catch (...) {
59127       {
59128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59129       };
59130     }
59131   }
59132
59133   jresult = (int)result;
59134   return jresult;
59135 }
59136
59137
59138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59139   int jresult ;
59140   int result;
59141
59142   {
59143     try {
59144       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59145     } catch (std::out_of_range& e) {
59146       {
59147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59148       };
59149     } catch (std::exception& e) {
59150       {
59151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59152       };
59153     } catch (Dali::DaliException e) {
59154       {
59155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59156       };
59157     } catch (...) {
59158       {
59159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59160       };
59161     }
59162   }
59163
59164   jresult = (int)result;
59165   return jresult;
59166 }
59167
59168
59169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59170   int jresult ;
59171   int result;
59172
59173   {
59174     try {
59175       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59176     } catch (std::out_of_range& e) {
59177       {
59178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59179       };
59180     } catch (std::exception& e) {
59181       {
59182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59183       };
59184     } catch (Dali::DaliException e) {
59185       {
59186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59187       };
59188     } catch (...) {
59189       {
59190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59191       };
59192     }
59193   }
59194
59195   jresult = (int)result;
59196   return jresult;
59197 }
59198
59199
59200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59201   int jresult ;
59202   int result;
59203
59204   {
59205     try {
59206       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59207     } catch (std::out_of_range& e) {
59208       {
59209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59210       };
59211     } catch (std::exception& e) {
59212       {
59213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59214       };
59215     } catch (Dali::DaliException e) {
59216       {
59217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59218       };
59219     } catch (...) {
59220       {
59221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59222       };
59223     }
59224   }
59225
59226   jresult = (int)result;
59227   return jresult;
59228 }
59229
59230
59231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59232   int jresult ;
59233   int result;
59234
59235   {
59236     try {
59237       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59238     } catch (std::out_of_range& e) {
59239       {
59240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59241       };
59242     } catch (std::exception& e) {
59243       {
59244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59245       };
59246     } catch (Dali::DaliException e) {
59247       {
59248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59249       };
59250     } catch (...) {
59251       {
59252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59253       };
59254     }
59255   }
59256
59257   jresult = (int)result;
59258   return jresult;
59259 }
59260
59261
59262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59263   int jresult ;
59264   int result;
59265
59266   {
59267     try {
59268       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59269     } catch (std::out_of_range& e) {
59270       {
59271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59272       };
59273     } catch (std::exception& e) {
59274       {
59275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59276       };
59277     } catch (Dali::DaliException e) {
59278       {
59279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59280       };
59281     } catch (...) {
59282       {
59283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59284       };
59285     }
59286   }
59287
59288   jresult = (int)result;
59289   return jresult;
59290 }
59291
59292
59293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59294   void * jresult ;
59295   Dali::Toolkit::Control result;
59296
59297   {
59298     try {
59299       result = Dali::Toolkit::Internal::Control::New();
59300     } catch (std::out_of_range& e) {
59301       {
59302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59303       };
59304     } catch (std::exception& e) {
59305       {
59306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59307       };
59308     } catch (Dali::DaliException e) {
59309       {
59310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59311       };
59312     } catch (...) {
59313       {
59314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59315       };
59316     }
59317   }
59318
59319   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59320   return jresult;
59321 }
59322
59323
59324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59326   std::string *arg2 = 0 ;
59327
59328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59329   if (!jarg2) {
59330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59331     return ;
59332   }
59333   std::string arg2_str(jarg2);
59334   arg2 = &arg2_str;
59335   {
59336     try {
59337       (arg1)->SetStyleName((std::string const &)*arg2);
59338     } catch (std::out_of_range& e) {
59339       {
59340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59341       };
59342     } catch (std::exception& e) {
59343       {
59344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59345       };
59346     } catch (Dali::DaliException e) {
59347       {
59348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59349       };
59350     } catch (...) {
59351       {
59352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59353       };
59354     }
59355   }
59356
59357
59358   //argout typemap for const std::string&
59359
59360 }
59361
59362
59363 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59364   char * jresult ;
59365   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59366   std::string *result = 0 ;
59367
59368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59369   {
59370     try {
59371       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59372     } catch (std::out_of_range& e) {
59373       {
59374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59375       };
59376     } catch (std::exception& e) {
59377       {
59378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59379       };
59380     } catch (Dali::DaliException e) {
59381       {
59382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59383       };
59384     } catch (...) {
59385       {
59386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59387       };
59388     }
59389   }
59390
59391   jresult = SWIG_csharp_string_callback(result->c_str());
59392   return jresult;
59393 }
59394
59395
59396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59397   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59398   Dali::Vector4 *arg2 = 0 ;
59399
59400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59401   arg2 = (Dali::Vector4 *)jarg2;
59402   if (!arg2) {
59403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59404     return ;
59405   }
59406   {
59407     try {
59408       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59409     } catch (std::out_of_range& e) {
59410       {
59411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59412       };
59413     } catch (std::exception& e) {
59414       {
59415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59416       };
59417     } catch (Dali::DaliException e) {
59418       {
59419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59420       };
59421     } catch (...) {
59422       {
59423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59424       };
59425     }
59426   }
59427
59428 }
59429
59430
59431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59432   void * jresult ;
59433   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59434   Dali::Vector4 result;
59435
59436   arg1 = (Dali::Handle *)jarg1;
59437   {
59438     try {
59439       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59440       if (resultMap)
59441       {
59442         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59443         if(type && type->Get<int>() == Visual::COLOR )
59444         {
59445           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59446           if (value)
59447           {
59448             result = value->Get<Vector4>();
59449           }
59450         }
59451       }
59452     } catch (std::out_of_range& e) {
59453       {
59454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59455       };
59456     } catch (std::exception& e) {
59457       {
59458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59459       };
59460     } catch (Dali::DaliException e) {
59461       {
59462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59463       };
59464     } catch (...) {
59465       {
59466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59467       };
59468     }
59469   }
59470
59471   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59472   return jresult;
59473 }
59474
59475
59476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59478   Dali::Property::Map *arg2 = 0 ;
59479
59480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59481   arg2 = (Dali::Property::Map *)jarg2;
59482   if (!arg2) {
59483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59484     return ;
59485   }
59486   {
59487     try {
59488       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59489     } catch (std::out_of_range& e) {
59490       {
59491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59492       };
59493     } catch (std::exception& e) {
59494       {
59495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59496       };
59497     } catch (Dali::DaliException e) {
59498       {
59499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59500       };
59501     } catch (...) {
59502       {
59503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59504       };
59505     }
59506   }
59507
59508 }
59509
59510
59511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59513
59514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59515   {
59516     try {
59517       (arg1)->ClearBackground();
59518     } catch (std::out_of_range& e) {
59519       {
59520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59521       };
59522     } catch (std::exception& e) {
59523       {
59524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59525       };
59526     } catch (Dali::DaliException e) {
59527       {
59528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59529       };
59530     } catch (...) {
59531       {
59532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59533       };
59534     }
59535   }
59536
59537 }
59538
59539
59540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59542   Dali::Gesture::Type arg2 ;
59543
59544   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59545   arg2 = (Dali::Gesture::Type)jarg2;
59546   {
59547     try {
59548       (arg1)->EnableGestureDetection(arg2);
59549     } catch (std::out_of_range& e) {
59550       {
59551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59552       };
59553     } catch (std::exception& e) {
59554       {
59555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59556       };
59557     } catch (Dali::DaliException e) {
59558       {
59559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59560       };
59561     } catch (...) {
59562       {
59563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59564       };
59565     }
59566   }
59567
59568 }
59569
59570
59571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59573   Dali::Gesture::Type arg2 ;
59574
59575   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59576   arg2 = (Dali::Gesture::Type)jarg2;
59577   {
59578     try {
59579       (arg1)->DisableGestureDetection(arg2);
59580     } catch (std::out_of_range& e) {
59581       {
59582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59583       };
59584     } catch (std::exception& e) {
59585       {
59586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59587       };
59588     } catch (Dali::DaliException e) {
59589       {
59590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59591       };
59592     } catch (...) {
59593       {
59594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59595       };
59596     }
59597   }
59598
59599 }
59600
59601
59602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59603   void * jresult ;
59604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59605   Dali::PinchGestureDetector result;
59606
59607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59608   {
59609     try {
59610       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59611     } catch (std::out_of_range& e) {
59612       {
59613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59614       };
59615     } catch (std::exception& e) {
59616       {
59617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59618       };
59619     } catch (Dali::DaliException e) {
59620       {
59621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59622       };
59623     } catch (...) {
59624       {
59625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59626       };
59627     }
59628   }
59629
59630   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59631   return jresult;
59632 }
59633
59634
59635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59636   void * jresult ;
59637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59638   Dali::PanGestureDetector result;
59639
59640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59641   {
59642     try {
59643       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59644     } catch (std::out_of_range& e) {
59645       {
59646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59647       };
59648     } catch (std::exception& e) {
59649       {
59650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59651       };
59652     } catch (Dali::DaliException e) {
59653       {
59654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59655       };
59656     } catch (...) {
59657       {
59658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59659       };
59660     }
59661   }
59662
59663   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59664   return jresult;
59665 }
59666
59667
59668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59669   void * jresult ;
59670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59671   Dali::TapGestureDetector result;
59672
59673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59674   {
59675     try {
59676       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59677     } catch (std::out_of_range& e) {
59678       {
59679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59680       };
59681     } catch (std::exception& e) {
59682       {
59683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59684       };
59685     } catch (Dali::DaliException e) {
59686       {
59687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59688       };
59689     } catch (...) {
59690       {
59691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59692       };
59693     }
59694   }
59695
59696   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59697   return jresult;
59698 }
59699
59700
59701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59702   void * jresult ;
59703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59704   Dali::LongPressGestureDetector result;
59705
59706   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59707   {
59708     try {
59709       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59710     } catch (std::out_of_range& e) {
59711       {
59712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59713       };
59714     } catch (std::exception& e) {
59715       {
59716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59717       };
59718     } catch (Dali::DaliException e) {
59719       {
59720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59721       };
59722     } catch (...) {
59723       {
59724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59725       };
59726     }
59727   }
59728
59729   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59730   return jresult;
59731 }
59732
59733
59734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59735   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59736   bool arg2 ;
59737
59738   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59739   arg2 = jarg2 ? true : false;
59740   {
59741     try {
59742       (arg1)->SetKeyboardNavigationSupport(arg2);
59743     } catch (std::out_of_range& e) {
59744       {
59745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59746       };
59747     } catch (std::exception& e) {
59748       {
59749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59750       };
59751     } catch (Dali::DaliException e) {
59752       {
59753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59754       };
59755     } catch (...) {
59756       {
59757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59758       };
59759     }
59760   }
59761
59762 }
59763
59764
59765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59766   unsigned int jresult ;
59767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59768   bool result;
59769
59770   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59771   {
59772     try {
59773       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59774     } catch (std::out_of_range& e) {
59775       {
59776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59777       };
59778     } catch (std::exception& e) {
59779       {
59780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59781       };
59782     } catch (Dali::DaliException e) {
59783       {
59784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59785       };
59786     } catch (...) {
59787       {
59788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59789       };
59790     }
59791   }
59792
59793   jresult = result;
59794   return jresult;
59795 }
59796
59797
59798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59800
59801   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59802   {
59803     try {
59804       (arg1)->SetKeyInputFocus();
59805     } catch (std::out_of_range& e) {
59806       {
59807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59808       };
59809     } catch (std::exception& e) {
59810       {
59811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59812       };
59813     } catch (Dali::DaliException e) {
59814       {
59815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59816       };
59817     } catch (...) {
59818       {
59819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59820       };
59821     }
59822   }
59823
59824 }
59825
59826
59827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59828   unsigned int jresult ;
59829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59830   bool result;
59831
59832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59833   {
59834     try {
59835       result = (bool)(arg1)->HasKeyInputFocus();
59836     } catch (std::out_of_range& e) {
59837       {
59838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59839       };
59840     } catch (std::exception& e) {
59841       {
59842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59843       };
59844     } catch (Dali::DaliException e) {
59845       {
59846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59847       };
59848     } catch (...) {
59849       {
59850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59851       };
59852     }
59853   }
59854
59855   jresult = result;
59856   return jresult;
59857 }
59858
59859
59860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59861   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59862
59863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59864   {
59865     try {
59866       (arg1)->ClearKeyInputFocus();
59867     } catch (std::out_of_range& e) {
59868       {
59869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59870       };
59871     } catch (std::exception& e) {
59872       {
59873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59874       };
59875     } catch (Dali::DaliException e) {
59876       {
59877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59878       };
59879     } catch (...) {
59880       {
59881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59882       };
59883     }
59884   }
59885
59886 }
59887
59888
59889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59890   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59891   bool arg2 ;
59892
59893   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59894   arg2 = jarg2 ? true : false;
59895   {
59896     try {
59897       (arg1)->SetAsKeyboardFocusGroup(arg2);
59898     } catch (std::out_of_range& e) {
59899       {
59900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59901       };
59902     } catch (std::exception& e) {
59903       {
59904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59905       };
59906     } catch (Dali::DaliException e) {
59907       {
59908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59909       };
59910     } catch (...) {
59911       {
59912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59913       };
59914     }
59915   }
59916
59917 }
59918
59919
59920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59921   unsigned int jresult ;
59922   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59923   bool result;
59924
59925   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59926   {
59927     try {
59928       result = (bool)(arg1)->IsKeyboardFocusGroup();
59929     } catch (std::out_of_range& e) {
59930       {
59931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59932       };
59933     } catch (std::exception& e) {
59934       {
59935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59936       };
59937     } catch (Dali::DaliException e) {
59938       {
59939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59940       };
59941     } catch (...) {
59942       {
59943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59944       };
59945     }
59946   }
59947
59948   jresult = result;
59949   return jresult;
59950 }
59951
59952
59953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59954   void * jresult ;
59955   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59956   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59957
59958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59959   {
59960     try {
59961       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59962     } catch (std::out_of_range& e) {
59963       {
59964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59965       };
59966     } catch (std::exception& e) {
59967       {
59968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59969       };
59970     } catch (Dali::DaliException e) {
59971       {
59972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59973       };
59974     } catch (...) {
59975       {
59976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59977       };
59978     }
59979   }
59980
59981   jresult = (void *)result;
59982   return jresult;
59983 }
59984
59985
59986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59987   void * jresult ;
59988   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59989   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59990
59991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59992   {
59993     try {
59994       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59995     } catch (std::out_of_range& e) {
59996       {
59997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59998       };
59999     } catch (std::exception& e) {
60000       {
60001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60002       };
60003     } catch (Dali::DaliException e) {
60004       {
60005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60006       };
60007     } catch (...) {
60008       {
60009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60010       };
60011     }
60012   }
60013
60014   jresult = (void *)result;
60015   return jresult;
60016 }
60017
60018
60019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60020   void * jresult ;
60021   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60022   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60023
60024   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60025   {
60026     try {
60027       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60028     } catch (std::out_of_range& e) {
60029       {
60030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60031       };
60032     } catch (std::exception& e) {
60033       {
60034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60035       };
60036     } catch (Dali::DaliException e) {
60037       {
60038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60039       };
60040     } catch (...) {
60041       {
60042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60043       };
60044     }
60045   }
60046
60047   jresult = (void *)result;
60048   return jresult;
60049 }
60050
60051
60052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
60053   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60054   int arg2 ;
60055   SwigDirector_ViewImpl *darg = 0;
60056
60057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60058   arg2 = (int)jarg2;
60059   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60060   if(!darg) {
60061     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60062     return;
60063   }
60064   {
60065     try {
60066       if(darg) {
60067         (darg)->OnSceneConnection(arg2);
60068       }
60069     } catch (std::out_of_range& e) {
60070       {
60071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60072       };
60073     } catch (std::exception& e) {
60074       {
60075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60076       };
60077     } catch (Dali::DaliException e) {
60078       {
60079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60080       };
60081     } catch (...) {
60082       {
60083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60084       };
60085     }
60086   }
60087
60088 }
60089
60090
60091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60092   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60093   int arg2 ;
60094   SwigDirector_ViewImpl *darg = 0;
60095
60096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60097   arg2 = (int)jarg2;
60098   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60099   if(!darg) {
60100     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60101     return;
60102   }
60103   {
60104     try {
60105       if(darg) {
60106         (darg)->OnSceneConnectionSwigPublic(arg2);
60107       }
60108     } catch (std::out_of_range& e) {
60109       {
60110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60111       };
60112     } catch (std::exception& e) {
60113       {
60114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60115       };
60116     } catch (Dali::DaliException e) {
60117       {
60118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60119       };
60120     } catch (...) {
60121       {
60122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60123       };
60124     }
60125   }
60126
60127 }
60128
60129
60130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
60131   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60132   SwigDirector_ViewImpl *darg = 0;
60133
60134   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60135   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60136   if(!darg) {
60137     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60138     return;
60139   }
60140   {
60141     try {
60142       if(darg) {
60143         (darg)->OnSceneDisconnection();
60144       }
60145     } catch (std::out_of_range& e) {
60146       {
60147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60148       };
60149     } catch (std::exception& e) {
60150       {
60151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60152       };
60153     } catch (Dali::DaliException e) {
60154       {
60155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60156       };
60157     } catch (...) {
60158       {
60159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60160       };
60161     }
60162   }
60163
60164 }
60165
60166
60167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
60168   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60169   SwigDirector_ViewImpl *darg = 0;
60170
60171   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60172   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60173   if(!darg) {
60174     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60175     return;
60176   }
60177   {
60178     try {
60179       if(darg) {
60180         (darg)->OnSceneDisconnectionSwigPublic();
60181       }
60182     } catch (std::out_of_range& e) {
60183       {
60184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60185       };
60186     } catch (std::exception& e) {
60187       {
60188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60189       };
60190     } catch (Dali::DaliException e) {
60191       {
60192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60193       };
60194     } catch (...) {
60195       {
60196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60197       };
60198     }
60199   }
60200
60201 }
60202
60203
60204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60206   Dali::Actor *arg2 = 0 ;
60207   SwigDirector_ViewImpl *darg = 0;
60208
60209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60210   arg2 = (Dali::Actor *)jarg2;
60211   if (!arg2) {
60212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60213     return ;
60214   }
60215   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60216   if(!darg) {
60217     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60218     return;
60219   }
60220   {
60221     try {
60222       if(darg) {
60223         (darg)->OnChildAdd(*arg2);
60224       }
60225     } catch (std::out_of_range& e) {
60226       {
60227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60228       };
60229     } catch (std::exception& e) {
60230       {
60231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60232       };
60233     } catch (Dali::DaliException e) {
60234       {
60235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60236       };
60237     } catch (...) {
60238       {
60239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60240       };
60241     }
60242   }
60243
60244 }
60245
60246
60247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60248   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60249   Dali::Actor *arg2 = 0 ;
60250   SwigDirector_ViewImpl *darg = 0;
60251
60252   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60253   arg2 = (Dali::Actor *)jarg2;
60254   if (!arg2) {
60255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60256     return ;
60257   }
60258   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60259   if(!darg) {
60260     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60261     return;
60262   }
60263   {
60264     try {
60265       if(darg) {
60266           (darg)->OnChildAddSwigPublic(*arg2);
60267       }
60268     } catch (std::out_of_range& e) {
60269       {
60270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60271       };
60272     } catch (std::exception& e) {
60273       {
60274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60275       };
60276     } catch (Dali::DaliException e) {
60277       {
60278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60279       };
60280     } catch (...) {
60281       {
60282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60283       };
60284     }
60285   }
60286
60287 }
60288
60289
60290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60292   Dali::Actor *arg2 = 0 ;
60293   SwigDirector_ViewImpl *darg = 0;
60294
60295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60296   arg2 = (Dali::Actor *)jarg2;
60297   if (!arg2) {
60298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60299     return ;
60300   }
60301   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60302   if(!darg) {
60303     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60304     return;
60305   }
60306   {
60307     try {
60308       if(darg) {
60309         (darg)->OnChildRemove(*arg2);
60310       }
60311     } catch (std::out_of_range& e) {
60312       {
60313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60314       };
60315     } catch (std::exception& e) {
60316       {
60317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60318       };
60319     } catch (Dali::DaliException e) {
60320       {
60321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60322       };
60323     } catch (...) {
60324       {
60325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60326       };
60327     }
60328   }
60329
60330 }
60331
60332
60333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60334   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60335   Dali::Actor *arg2 = 0 ;
60336   SwigDirector_ViewImpl *darg = 0;
60337
60338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60339   arg2 = (Dali::Actor *)jarg2;
60340   if (!arg2) {
60341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60342     return ;
60343   }
60344   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60345   if(!darg) {
60346     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60347     return;
60348   }
60349   {
60350     try {
60351       if(darg) {
60352         (darg)->OnChildRemoveSwigPublic(*arg2);
60353       }
60354     } catch (std::out_of_range& e) {
60355       {
60356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60357       };
60358     } catch (std::exception& e) {
60359       {
60360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60361       };
60362     } catch (Dali::DaliException e) {
60363       {
60364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60365       };
60366     } catch (...) {
60367       {
60368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60369       };
60370     }
60371   }
60372
60373 }
60374
60375
60376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60377   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60378   Dali::Property::Index arg2 ;
60379   Dali::Property::Value arg3 ;
60380   Dali::Property::Value *argp3 ;
60381   SwigDirector_ViewImpl *darg = 0;
60382
60383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60384   arg2 = (Dali::Property::Index)jarg2;
60385   argp3 = (Dali::Property::Value *)jarg3;
60386   if (!argp3) {
60387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60388     return ;
60389   }
60390   arg3 = *argp3;
60391   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60392   if (!darg) {
60393     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60394     return;
60395   }
60396   {
60397     try {
60398       (darg)->OnPropertySet(arg2,arg3);
60399     } catch (std::out_of_range& e) {
60400       {
60401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60402       };
60403     } catch (std::exception& e) {
60404       {
60405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60406       };
60407     } catch (Dali::DaliException e) {
60408       {
60409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60410       };
60411     } catch (...) {
60412       {
60413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60414       };
60415     }
60416   }
60417
60418 }
60419
60420
60421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60422   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60423   Dali::Property::Index arg2 ;
60424   Dali::Property::Value arg3 ;
60425   Dali::Property::Value *argp3 ;
60426   SwigDirector_ViewImpl *darg = 0;
60427
60428   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60429   arg2 = (Dali::Property::Index)jarg2;
60430   argp3 = (Dali::Property::Value *)jarg3;
60431   if (!argp3) {
60432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60433     return ;
60434   }
60435   arg3 = *argp3;
60436   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60437   if (!darg) {
60438     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60439     return;
60440   }
60441   {
60442     try {
60443       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60444     } catch (std::out_of_range& e) {
60445       {
60446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60447       };
60448     } catch (std::exception& e) {
60449       {
60450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60451       };
60452     } catch (Dali::DaliException e) {
60453       {
60454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60455       };
60456     } catch (...) {
60457       {
60458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60459       };
60460     }
60461   }
60462
60463 }
60464
60465
60466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60468   Dali::Vector3 *arg2 = 0 ;
60469   SwigDirector_ViewImpl *darg = 0;
60470
60471   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60472   arg2 = (Dali::Vector3 *)jarg2;
60473   if (!arg2) {
60474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60475     return ;
60476   }
60477   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60478   if (!darg) {
60479     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60480     return;
60481   }
60482   {
60483     try {
60484       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60485     } catch (std::out_of_range& e) {
60486       {
60487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60488       };
60489     } catch (std::exception& e) {
60490       {
60491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60492       };
60493     } catch (Dali::DaliException e) {
60494       {
60495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60496       };
60497     } catch (...) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60500       };
60501     }
60502   }
60503
60504 }
60505
60506
60507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60509   Dali::Vector3 *arg2 = 0 ;
60510   SwigDirector_ViewImpl *darg = 0;
60511
60512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60513   arg2 = (Dali::Vector3 *)jarg2;
60514   if (!arg2) {
60515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60516     return ;
60517   }
60518   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60519   if (!darg) {
60520     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60521     return;
60522   }
60523   {
60524     try {
60525       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60526     } catch (std::out_of_range& e) {
60527       {
60528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60529       };
60530     } catch (std::exception& e) {
60531       {
60532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60533       };
60534     } catch (Dali::DaliException e) {
60535       {
60536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60537       };
60538     } catch (...) {
60539       {
60540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60541       };
60542     }
60543   }
60544
60545 }
60546
60547
60548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60550   Dali::Animation *arg2 = 0 ;
60551   Dali::Vector3 *arg3 = 0 ;
60552   SwigDirector_ViewImpl *darg = 0;
60553
60554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60555   arg2 = (Dali::Animation *)jarg2;
60556   if (!arg2) {
60557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60558     return ;
60559   }
60560   arg3 = (Dali::Vector3 *)jarg3;
60561   if (!arg3) {
60562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60563     return ;
60564   }
60565   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60566   if (!darg) {
60567     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60568     return;
60569   }
60570   {
60571     try {
60572       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60573     } catch (std::out_of_range& e) {
60574       {
60575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60576       };
60577     } catch (std::exception& e) {
60578       {
60579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60580       };
60581     } catch (Dali::DaliException e) {
60582       {
60583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60584       };
60585     } catch (...) {
60586       {
60587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60588       };
60589     }
60590   }
60591
60592 }
60593
60594
60595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60597   Dali::Animation *arg2 = 0 ;
60598   Dali::Vector3 *arg3 = 0 ;
60599   SwigDirector_ViewImpl *darg = 0;
60600
60601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60602   arg2 = (Dali::Animation *)jarg2;
60603   if (!arg2) {
60604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60605     return ;
60606   }
60607   arg3 = (Dali::Vector3 *)jarg3;
60608   if (!arg3) {
60609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60610     return ;
60611   }
60612   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60613   if (!darg) {
60614     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60615     return;
60616   }
60617   {
60618     try {
60619       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60620     } catch (std::out_of_range& e) {
60621       {
60622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60623       };
60624     } catch (std::exception& e) {
60625       {
60626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60627       };
60628     } catch (Dali::DaliException e) {
60629       {
60630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60631       };
60632     } catch (...) {
60633       {
60634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60635       };
60636     }
60637   }
60638 }
60639
60640
60641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60642   unsigned int jresult ;
60643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60644   Dali::HoverEvent *arg2 = 0 ;
60645   SwigDirector_ViewImpl *darg = 0;
60646   bool result;
60647
60648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60649   arg2 = (Dali::HoverEvent *)jarg2;
60650   if (!arg2) {
60651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60652     return 0;
60653   }
60654   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60655   if (!darg) {
60656     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60657     return 0;
60658   }
60659   {
60660     try {
60661       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60662     } catch (std::out_of_range& e) {
60663       {
60664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60665       };
60666     } catch (std::exception& e) {
60667       {
60668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60669       };
60670     } catch (Dali::DaliException e) {
60671       {
60672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60673       };
60674     } catch (...) {
60675       {
60676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60677       };
60678     }
60679   }
60680
60681   jresult = result;
60682   return jresult;
60683 }
60684
60685
60686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60687   unsigned int jresult ;
60688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60689   Dali::HoverEvent *arg2 = 0 ;
60690   SwigDirector_ViewImpl *darg = 0;
60691   bool result;
60692
60693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60694   arg2 = (Dali::HoverEvent *)jarg2;
60695   if (!arg2) {
60696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60697     return 0;
60698   }
60699   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60700   if (!darg) {
60701     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60702     return 0;
60703   }
60704   {
60705     try {
60706       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60707     } catch (std::out_of_range& e) {
60708       {
60709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60710       };
60711     } catch (std::exception& e) {
60712       {
60713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60714       };
60715     } catch (Dali::DaliException e) {
60716       {
60717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60718       };
60719     } catch (...) {
60720       {
60721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60722       };
60723     }
60724   }
60725
60726   jresult = result;
60727   return jresult;
60728 }
60729
60730
60731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60732   unsigned int jresult ;
60733   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60734   Dali::KeyEvent *arg2 = 0 ;
60735   SwigDirector_ViewImpl *darg = 0;
60736   bool result;
60737
60738   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60739   arg2 = (Dali::KeyEvent *)jarg2;
60740   if (!arg2) {
60741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60742     return 0;
60743   }
60744   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60745   if (!darg) {
60746     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60747     return 0;
60748   }
60749   {
60750     try {
60751       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60752     } catch (std::out_of_range& e) {
60753       {
60754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60755       };
60756     } catch (std::exception& e) {
60757       {
60758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60759       };
60760     } catch (Dali::DaliException e) {
60761       {
60762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60763       };
60764     } catch (...) {
60765       {
60766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60767       };
60768     }
60769   }
60770
60771   jresult = result;
60772   return jresult;
60773 }
60774
60775
60776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60777   unsigned int jresult ;
60778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60779   Dali::KeyEvent *arg2 = 0 ;
60780   SwigDirector_ViewImpl *darg = 0;
60781   bool result;
60782
60783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60784   arg2 = (Dali::KeyEvent *)jarg2;
60785   if (!arg2) {
60786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60787     return 0;
60788   }
60789   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60790   if (!darg) {
60791     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60792     return 0;
60793   }
60794   {
60795     try {
60796       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60797     } catch (std::out_of_range& e) {
60798       {
60799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60800       };
60801     } catch (std::exception& e) {
60802       {
60803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60804       };
60805     } catch (Dali::DaliException e) {
60806       {
60807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60808       };
60809     } catch (...) {
60810       {
60811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60812       };
60813     }
60814   }
60815
60816   jresult = result;
60817   return jresult;
60818 }
60819
60820
60821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60822   unsigned int jresult ;
60823   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60824   Dali::WheelEvent *arg2 = 0 ;
60825   SwigDirector_ViewImpl *darg = 0;
60826   bool result;
60827
60828   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60829   arg2 = (Dali::WheelEvent *)jarg2;
60830   if (!arg2) {
60831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60832     return 0;
60833   }
60834   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60835   if (!darg) {
60836     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60837     return 0;
60838   }
60839   {
60840     try {
60841       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60842     } catch (std::out_of_range& e) {
60843       {
60844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60845       };
60846     } catch (std::exception& e) {
60847       {
60848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60849       };
60850     } catch (Dali::DaliException e) {
60851       {
60852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60853       };
60854     } catch (...) {
60855       {
60856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60857       };
60858     }
60859   }
60860
60861   jresult = result;
60862   return jresult;
60863 }
60864
60865
60866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60867   unsigned int jresult ;
60868   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60869   Dali::WheelEvent *arg2 = 0 ;
60870   SwigDirector_ViewImpl *darg = 0;
60871   bool result;
60872
60873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60874   arg2 = (Dali::WheelEvent *)jarg2;
60875   if (!arg2) {
60876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60877     return 0;
60878   }
60879   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60880   if (!darg) {
60881     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60882     return 0;
60883   }
60884   {
60885     try {
60886       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60887     } catch (std::out_of_range& e) {
60888       {
60889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60890       };
60891     } catch (std::exception& e) {
60892       {
60893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60894       };
60895     } catch (Dali::DaliException e) {
60896       {
60897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60898       };
60899     } catch (...) {
60900       {
60901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60902       };
60903     }
60904   }
60905
60906   jresult = result;
60907   return jresult;
60908 }
60909
60910
60911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60913   Dali::Vector2 *arg2 = 0 ;
60914   Dali::RelayoutContainer *arg3 = 0 ;
60915   SwigDirector_ViewImpl *darg = 0;
60916
60917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60918   arg2 = (Dali::Vector2 *)jarg2;
60919   if (!arg2) {
60920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60921     return ;
60922   }
60923   arg3 = (Dali::RelayoutContainer *)jarg3;
60924   if (!arg3) {
60925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60926     return ;
60927   }
60928   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60929   if (!darg) {
60930     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60931     return;
60932   }
60933   {
60934     try {
60935       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60936     } catch (std::out_of_range& e) {
60937       {
60938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60939       };
60940     } catch (std::exception& e) {
60941       {
60942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60943       };
60944     } catch (Dali::DaliException e) {
60945       {
60946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60947       };
60948     } catch (...) {
60949       {
60950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60951       };
60952     }
60953   }
60954
60955 }
60956
60957
60958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60960   Dali::Vector2 *arg2 = 0 ;
60961   Dali::RelayoutContainer *arg3 = 0 ;
60962   SwigDirector_ViewImpl *darg = 0;
60963
60964   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60965   arg2 = (Dali::Vector2 *)jarg2;
60966   if (!arg2) {
60967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60968     return ;
60969   }
60970   arg3 = (Dali::RelayoutContainer *)jarg3;
60971   if (!arg3) {
60972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60973     return ;
60974   }
60975   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60976   if (!darg) {
60977     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60978     return;
60979   }
60980   {
60981     try {
60982       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60983     } catch (std::out_of_range& e) {
60984       {
60985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60986       };
60987     } catch (std::exception& e) {
60988       {
60989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60990       };
60991     } catch (Dali::DaliException e) {
60992       {
60993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60994       };
60995     } catch (...) {
60996       {
60997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60998       };
60999     }
61000   }
61001
61002 }
61003
61004
61005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61006   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61007   Dali::ResizePolicy::Type arg2 ;
61008   Dali::Dimension::Type arg3 ;
61009   SwigDirector_ViewImpl *darg = 0;
61010
61011   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61012   arg2 = (Dali::ResizePolicy::Type)jarg2;
61013   arg3 = (Dali::Dimension::Type)jarg3;
61014   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61015   if (!darg) {
61016     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61017     return;
61018   }
61019   {
61020     try {
61021       (darg)->OnSetResizePolicy(arg2,arg3);
61022     } catch (std::out_of_range& e) {
61023       {
61024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61025       };
61026     } catch (std::exception& e) {
61027       {
61028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61029       };
61030     } catch (Dali::DaliException e) {
61031       {
61032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61033       };
61034     } catch (...) {
61035       {
61036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61037       };
61038     }
61039   }
61040
61041 }
61042
61043
61044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61045   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61046   Dali::ResizePolicy::Type arg2 ;
61047   Dali::Dimension::Type arg3 ;
61048   SwigDirector_ViewImpl *darg = 0;
61049
61050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61051   arg2 = (Dali::ResizePolicy::Type)jarg2;
61052   arg3 = (Dali::Dimension::Type)jarg3;
61053   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61054   if (!darg) {
61055     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61056     return;
61057   }
61058   {
61059     try {
61060       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61061     } catch (std::out_of_range& e) {
61062       {
61063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61064       };
61065     } catch (std::exception& e) {
61066       {
61067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61068       };
61069     } catch (Dali::DaliException e) {
61070       {
61071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61072       };
61073     } catch (...) {
61074       {
61075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61076       };
61077     }
61078   }
61079
61080 }
61081
61082
61083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61084   void * jresult ;
61085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61086   SwigDirector_ViewImpl *darg = 0;
61087   Dali::Vector3 result;
61088
61089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61090   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61091   if (!darg) {
61092     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61093     return 0;
61094   }
61095   {
61096     try {
61097       result = (darg)->GetNaturalSize();
61098     } catch (std::out_of_range& e) {
61099       {
61100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61101       };
61102     } catch (std::exception& e) {
61103       {
61104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61105       };
61106     } catch (Dali::DaliException e) {
61107       {
61108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61109       };
61110     } catch (...) {
61111       {
61112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61113       };
61114     }
61115   }
61116
61117   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61118   return jresult;
61119 }
61120
61121
61122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61123   void * jresult ;
61124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61125   SwigDirector_ViewImpl *darg = 0;
61126   Dali::Vector3 result;
61127
61128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61129   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61130   if (!darg) {
61131     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61132     return 0;
61133   }
61134   {
61135     try {
61136       result = (darg)->GetNaturalSizeSwigPublic();
61137     } catch (std::out_of_range& e) {
61138       {
61139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61140       };
61141     } catch (std::exception& e) {
61142       {
61143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61144       };
61145     } catch (Dali::DaliException e) {
61146       {
61147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61148       };
61149     } catch (...) {
61150       {
61151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61152       };
61153     }
61154   }
61155
61156   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61157   return jresult;
61158 }
61159
61160
61161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61162   float jresult ;
61163   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61164   Dali::Actor *arg2 = 0 ;
61165   Dali::Dimension::Type arg3 ;
61166   SwigDirector_ViewImpl *darg = 0;
61167   float result;
61168
61169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61170   arg2 = (Dali::Actor *)jarg2;
61171   if (!arg2) {
61172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61173     return 0;
61174   }
61175   arg3 = (Dali::Dimension::Type)jarg3;
61176   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61177   if (!darg) {
61178     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61179     return 0;
61180   }
61181   {
61182     try {
61183       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61184     } catch (std::out_of_range& e) {
61185       {
61186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61187       };
61188     } catch (std::exception& e) {
61189       {
61190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61191       };
61192     } catch (Dali::DaliException e) {
61193       {
61194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61195       };
61196     } catch (...) {
61197       {
61198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61199       };
61200     }
61201   }
61202
61203   jresult = result;
61204   return jresult;
61205 }
61206
61207
61208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61209   float jresult ;
61210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61211   Dali::Actor *arg2 = 0 ;
61212   Dali::Dimension::Type arg3 ;
61213   SwigDirector_ViewImpl *darg = 0;
61214   float result;
61215
61216   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61217   arg2 = (Dali::Actor *)jarg2;
61218   if (!arg2) {
61219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61220     return 0;
61221   }
61222   arg3 = (Dali::Dimension::Type)jarg3;
61223   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61224   if (!darg) {
61225     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61226     return 0;
61227   }
61228   {
61229     try {
61230       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61231     } catch (std::out_of_range& e) {
61232       {
61233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61234       };
61235     } catch (std::exception& e) {
61236       {
61237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61238       };
61239     } catch (Dali::DaliException e) {
61240       {
61241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61242       };
61243     } catch (...) {
61244       {
61245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61246       };
61247     }
61248   }
61249
61250   jresult = result;
61251   return jresult;
61252 }
61253
61254
61255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61256   float jresult ;
61257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61258   float arg2 ;
61259   SwigDirector_ViewImpl *darg = 0;
61260   float result;
61261
61262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61263   arg2 = (float)jarg2;
61264   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61265   if (!darg) {
61266     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61267     return 0;
61268   }
61269   {
61270     try {
61271       result = (float)(darg)->GetHeightForWidth(arg2);
61272     } catch (std::out_of_range& e) {
61273       {
61274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61275       };
61276     } catch (std::exception& e) {
61277       {
61278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61279       };
61280     } catch (Dali::DaliException e) {
61281       {
61282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61283       };
61284     } catch (...) {
61285       {
61286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61287       };
61288     }
61289   }
61290
61291   jresult = result;
61292   return jresult;
61293 }
61294
61295
61296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61297   float jresult ;
61298   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61299   float arg2 ;
61300   SwigDirector_ViewImpl *darg = 0;
61301   float result;
61302
61303   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61304   arg2 = (float)jarg2;
61305   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61306   if (!darg) {
61307     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61308     return 0;
61309   }
61310   {
61311     try {
61312       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61313     } catch (std::out_of_range& e) {
61314       {
61315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61316       };
61317     } catch (std::exception& e) {
61318       {
61319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61320       };
61321     } catch (Dali::DaliException e) {
61322       {
61323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61324       };
61325     } catch (...) {
61326       {
61327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61328       };
61329     }
61330   }
61331
61332   jresult = result;
61333   return jresult;
61334 }
61335
61336
61337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61338   float jresult ;
61339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61340   float arg2 ;
61341   SwigDirector_ViewImpl *darg = 0;
61342   float result;
61343
61344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61345   arg2 = (float)jarg2;
61346   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61347   if (!darg) {
61348     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61349     return 0;
61350   }
61351   {
61352     try {
61353       result = (float)(darg)->GetWidthForHeight(arg2);
61354     } catch (std::out_of_range& e) {
61355       {
61356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61357       };
61358     } catch (std::exception& e) {
61359       {
61360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61361       };
61362     } catch (Dali::DaliException e) {
61363       {
61364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61365       };
61366     } catch (...) {
61367       {
61368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61369       };
61370     }
61371   }
61372
61373   jresult = result;
61374   return jresult;
61375 }
61376
61377
61378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61379   float jresult ;
61380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61381   float arg2 ;
61382   SwigDirector_ViewImpl *darg = 0;
61383   float result;
61384
61385   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61386   arg2 = (float)jarg2;
61387   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61388   if (!darg) {
61389     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61390     return 0;
61391   }
61392   {
61393     try {
61394       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61395     } catch (std::out_of_range& e) {
61396       {
61397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61398       };
61399     } catch (std::exception& e) {
61400       {
61401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61402       };
61403     } catch (Dali::DaliException e) {
61404       {
61405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61406       };
61407     } catch (...) {
61408       {
61409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61410       };
61411     }
61412   }
61413
61414   jresult = result;
61415   return jresult;
61416 }
61417
61418
61419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61420   unsigned int jresult ;
61421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61422   Dali::Dimension::Type arg2 ;
61423   SwigDirector_ViewImpl *darg = 0;
61424   bool result;
61425
61426   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61427   arg2 = (Dali::Dimension::Type)jarg2;
61428   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61429   if (!darg) {
61430     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61431     return 0;
61432   }
61433   {
61434     try {
61435       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61436     } catch (std::out_of_range& e) {
61437       {
61438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61439       };
61440     } catch (std::exception& e) {
61441       {
61442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61443       };
61444     } catch (Dali::DaliException e) {
61445       {
61446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61447       };
61448     } catch (...) {
61449       {
61450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61451       };
61452     }
61453   }
61454
61455   jresult = result;
61456   return jresult;
61457 }
61458
61459
61460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61461   unsigned int jresult ;
61462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61463   Dali::Dimension::Type arg2 ;
61464   SwigDirector_ViewImpl *darg = 0;
61465   bool result;
61466
61467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61468   arg2 = (Dali::Dimension::Type)jarg2;
61469   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61470   if (!darg) {
61471     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61472     return 0;
61473   }
61474   {
61475     try {
61476       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61477     } catch (std::out_of_range& e) {
61478       {
61479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61480       };
61481     } catch (std::exception& e) {
61482       {
61483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61484       };
61485     } catch (Dali::DaliException e) {
61486       {
61487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61488       };
61489     } catch (...) {
61490       {
61491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61492       };
61493     }
61494   }
61495
61496   jresult = result;
61497   return jresult;
61498 }
61499
61500
61501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61502   unsigned int jresult ;
61503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61504   SwigDirector_ViewImpl *darg = 0;
61505   bool result;
61506
61507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61508   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61509   if (!darg) {
61510     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61511     return 0;
61512   }
61513   {
61514     try {
61515       result = (bool)(darg)->RelayoutDependentOnChildren();
61516     } catch (std::out_of_range& e) {
61517       {
61518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61519       };
61520     } catch (std::exception& e) {
61521       {
61522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61523       };
61524     } catch (Dali::DaliException e) {
61525       {
61526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61527       };
61528     } catch (...) {
61529       {
61530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61531       };
61532     }
61533   }
61534
61535   jresult = result;
61536   return jresult;
61537 }
61538
61539
61540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61541   unsigned int jresult ;
61542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61543   SwigDirector_ViewImpl *darg = 0;
61544   bool result;
61545
61546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61547   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61548   if (!darg) {
61549     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61550     return 0;
61551   }
61552   {
61553     try {
61554       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61555     } catch (std::out_of_range& e) {
61556       {
61557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61558       };
61559     } catch (std::exception& e) {
61560       {
61561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61562       };
61563     } catch (Dali::DaliException e) {
61564       {
61565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61566       };
61567     } catch (...) {
61568       {
61569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61570       };
61571     }
61572   }
61573
61574   jresult = result;
61575   return jresult;
61576 }
61577
61578
61579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61580   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61581   Dali::Dimension::Type arg2 ;
61582   SwigDirector_ViewImpl *darg = 0;
61583
61584   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61585   arg2 = (Dali::Dimension::Type)jarg2;
61586   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61587   if (!darg) {
61588     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61589     return;
61590   }
61591   {
61592     try {
61593       (darg)->OnCalculateRelayoutSize(arg2);
61594     } catch (std::out_of_range& e) {
61595       {
61596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61597       };
61598     } catch (std::exception& e) {
61599       {
61600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61601       };
61602     } catch (Dali::DaliException e) {
61603       {
61604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61605       };
61606     } catch (...) {
61607       {
61608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61609       };
61610     }
61611   }
61612
61613 }
61614
61615
61616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61617   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61618   Dali::Dimension::Type arg2 ;
61619   SwigDirector_ViewImpl *darg = 0;
61620
61621   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61622   arg2 = (Dali::Dimension::Type)jarg2;
61623   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61624   if (!darg) {
61625     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61626     return;
61627   }
61628   {
61629     try {
61630       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61631     } catch (std::out_of_range& e) {
61632       {
61633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61634       };
61635     } catch (std::exception& e) {
61636       {
61637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61638       };
61639     } catch (Dali::DaliException e) {
61640       {
61641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61642       };
61643     } catch (...) {
61644       {
61645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61646       };
61647     }
61648   }
61649
61650 }
61651
61652
61653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61654   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61655   float arg2 ;
61656   Dali::Dimension::Type arg3 ;
61657   SwigDirector_ViewImpl *darg = 0;
61658
61659   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61660   arg2 = (float)jarg2;
61661   arg3 = (Dali::Dimension::Type)jarg3;
61662   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61663   if (!darg) {
61664     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61665     return;
61666   }
61667   {
61668     try {
61669       (darg)->OnLayoutNegotiated(arg2,arg3);
61670     } catch (std::out_of_range& e) {
61671       {
61672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61673       };
61674     } catch (std::exception& e) {
61675       {
61676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61677       };
61678     } catch (Dali::DaliException e) {
61679       {
61680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61681       };
61682     } catch (...) {
61683       {
61684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61685       };
61686     }
61687   }
61688
61689 }
61690
61691
61692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61694   float arg2 ;
61695   Dali::Dimension::Type arg3 ;
61696   SwigDirector_ViewImpl *darg = 0;
61697
61698   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61699   arg2 = (float)jarg2;
61700   arg3 = (Dali::Dimension::Type)jarg3;
61701   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61702   if (!darg) {
61703     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61704     return;
61705   }
61706   {
61707     try {
61708       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61709     } catch (std::out_of_range& e) {
61710       {
61711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61712       };
61713     } catch (std::exception& e) {
61714       {
61715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61716       };
61717     } catch (Dali::DaliException e) {
61718       {
61719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61720       };
61721     } catch (...) {
61722       {
61723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61724       };
61725     }
61726   }
61727
61728 }
61729
61730
61731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61732   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61733
61734   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61735   {
61736     try {
61737       (arg1)->OnInitialize();
61738     } catch (std::out_of_range& e) {
61739       {
61740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61741       };
61742     } catch (std::exception& e) {
61743       {
61744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61745       };
61746     } catch (Dali::DaliException e) {
61747       {
61748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61749       };
61750     } catch (...) {
61751       {
61752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61753       };
61754     }
61755   }
61756
61757 }
61758
61759
61760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61761   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61762
61763   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61764   {
61765     try {
61766       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61767     } catch (std::out_of_range& e) {
61768       {
61769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61770       };
61771     } catch (std::exception& e) {
61772       {
61773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61774       };
61775     } catch (Dali::DaliException e) {
61776       {
61777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61778       };
61779     } catch (...) {
61780       {
61781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61782       };
61783     }
61784   }
61785
61786 }
61787
61788
61789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61790   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61791   Dali::Toolkit::StyleManager arg2 ;
61792   Dali::StyleChange::Type arg3 ;
61793   Dali::Toolkit::StyleManager *argp2 ;
61794
61795   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61796   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61797   if (!argp2) {
61798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61799     return ;
61800   }
61801   arg2 = *argp2;
61802   arg3 = (Dali::StyleChange::Type)jarg3;
61803   {
61804     try {
61805       (arg1)->OnStyleChange(arg2,arg3);
61806     } catch (std::out_of_range& e) {
61807       {
61808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61809       };
61810     } catch (std::exception& e) {
61811       {
61812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61813       };
61814     } catch (Dali::DaliException e) {
61815       {
61816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61817       };
61818     } catch (...) {
61819       {
61820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61821       };
61822     }
61823   }
61824
61825 }
61826
61827
61828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61830   Dali::Toolkit::StyleManager arg2 ;
61831   Dali::StyleChange::Type arg3 ;
61832   Dali::Toolkit::StyleManager *argp2 ;
61833
61834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61835   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61836   if (!argp2) {
61837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61838     return ;
61839   }
61840   arg2 = *argp2;
61841   arg3 = (Dali::StyleChange::Type)jarg3;
61842   {
61843     try {
61844       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61845     } catch (std::out_of_range& e) {
61846       {
61847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61848       };
61849     } catch (std::exception& e) {
61850       {
61851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61852       };
61853     } catch (Dali::DaliException e) {
61854       {
61855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61856       };
61857     } catch (...) {
61858       {
61859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61860       };
61861     }
61862   }
61863
61864 }
61865
61866
61867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61868   unsigned int jresult ;
61869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61870   bool result;
61871
61872   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61873   {
61874     try {
61875       result = (bool)(arg1)->OnAccessibilityActivated();
61876     } catch (std::out_of_range& e) {
61877       {
61878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61879       };
61880     } catch (std::exception& e) {
61881       {
61882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61883       };
61884     } catch (Dali::DaliException e) {
61885       {
61886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61887       };
61888     } catch (...) {
61889       {
61890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61891       };
61892     }
61893   }
61894
61895   jresult = result;
61896   return jresult;
61897 }
61898
61899
61900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61901   unsigned int jresult ;
61902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61903   bool result;
61904
61905   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61906   {
61907     try {
61908       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61909     } catch (std::out_of_range& e) {
61910       {
61911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61912       };
61913     } catch (std::exception& e) {
61914       {
61915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61916       };
61917     } catch (Dali::DaliException e) {
61918       {
61919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61920       };
61921     } catch (...) {
61922       {
61923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61924       };
61925     }
61926   }
61927
61928   jresult = result;
61929   return jresult;
61930 }
61931
61932
61933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61934   unsigned int jresult ;
61935   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61936   Dali::PanGesture arg2 ;
61937   Dali::PanGesture *argp2 ;
61938   bool result;
61939
61940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61941   argp2 = (Dali::PanGesture *)jarg2;
61942   if (!argp2) {
61943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61944     return 0;
61945   }
61946   arg2 = *argp2;
61947   {
61948     try {
61949       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61950     } catch (std::out_of_range& e) {
61951       {
61952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61953       };
61954     } catch (std::exception& e) {
61955       {
61956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61957       };
61958     } catch (Dali::DaliException e) {
61959       {
61960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61961       };
61962     } catch (...) {
61963       {
61964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61965       };
61966     }
61967   }
61968
61969   jresult = result;
61970   return jresult;
61971 }
61972
61973
61974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61975   unsigned int jresult ;
61976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61977   Dali::PanGesture arg2 ;
61978   Dali::PanGesture *argp2 ;
61979   bool result;
61980
61981   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61982   argp2 = (Dali::PanGesture *)jarg2;
61983   if (!argp2) {
61984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61985     return 0;
61986   }
61987   arg2 = *argp2;
61988   {
61989     try {
61990       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61991     } catch (std::out_of_range& e) {
61992       {
61993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61994       };
61995     } catch (std::exception& e) {
61996       {
61997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61998       };
61999     } catch (Dali::DaliException e) {
62000       {
62001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62002       };
62003     } catch (...) {
62004       {
62005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62006       };
62007     }
62008   }
62009
62010   jresult = result;
62011   return jresult;
62012 }
62013
62014
62015
62016
62017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62018   unsigned int jresult ;
62019   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62020   bool arg2 ;
62021   bool result;
62022
62023   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62024   arg2 = jarg2 ? true : false;
62025   {
62026     try {
62027       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62028     } catch (std::out_of_range& e) {
62029       {
62030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62031       };
62032     } catch (std::exception& e) {
62033       {
62034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62035       };
62036     } catch (Dali::DaliException e) {
62037       {
62038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62039       };
62040     } catch (...) {
62041       {
62042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62043       };
62044     }
62045   }
62046
62047   jresult = result;
62048   return jresult;
62049 }
62050
62051
62052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62053   unsigned int jresult ;
62054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62055   bool arg2 ;
62056   bool result;
62057
62058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62059   arg2 = jarg2 ? true : false;
62060   {
62061     try {
62062       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62063     } catch (std::out_of_range& e) {
62064       {
62065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62066       };
62067     } catch (std::exception& e) {
62068       {
62069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62070       };
62071     } catch (Dali::DaliException e) {
62072       {
62073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62074       };
62075     } catch (...) {
62076       {
62077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62078       };
62079     }
62080   }
62081
62082   jresult = result;
62083   return jresult;
62084 }
62085
62086
62087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62088   unsigned int jresult ;
62089   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62090   bool result;
62091
62092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62093   {
62094     try {
62095       result = (bool)(arg1)->OnAccessibilityZoom();
62096     } catch (std::out_of_range& e) {
62097       {
62098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62099       };
62100     } catch (std::exception& e) {
62101       {
62102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62103       };
62104     } catch (Dali::DaliException e) {
62105       {
62106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62107       };
62108     } catch (...) {
62109       {
62110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62111       };
62112     }
62113   }
62114
62115   jresult = result;
62116   return jresult;
62117 }
62118
62119
62120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62121   unsigned int jresult ;
62122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62123   bool result;
62124
62125   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62126   {
62127     try {
62128       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62129     } catch (std::out_of_range& e) {
62130       {
62131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62132       };
62133     } catch (std::exception& e) {
62134       {
62135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62136       };
62137     } catch (Dali::DaliException e) {
62138       {
62139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62140       };
62141     } catch (...) {
62142       {
62143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62144       };
62145     }
62146   }
62147
62148   jresult = result;
62149   return jresult;
62150 }
62151
62152
62153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62154   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62155
62156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62157   {
62158     try {
62159       (arg1)->OnKeyInputFocusGained();
62160     } catch (std::out_of_range& e) {
62161       {
62162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62163       };
62164     } catch (std::exception& e) {
62165       {
62166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62167       };
62168     } catch (Dali::DaliException e) {
62169       {
62170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62171       };
62172     } catch (...) {
62173       {
62174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62175       };
62176     }
62177   }
62178
62179 }
62180
62181
62182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62183   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62184
62185   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62186   {
62187     try {
62188       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62189     } catch (std::out_of_range& e) {
62190       {
62191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62192       };
62193     } catch (std::exception& e) {
62194       {
62195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62196       };
62197     } catch (Dali::DaliException e) {
62198       {
62199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62200       };
62201     } catch (...) {
62202       {
62203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62204       };
62205     }
62206   }
62207
62208 }
62209
62210
62211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62213
62214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62215   {
62216     try {
62217       (arg1)->OnKeyInputFocusLost();
62218     } catch (std::out_of_range& e) {
62219       {
62220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62221       };
62222     } catch (std::exception& e) {
62223       {
62224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62225       };
62226     } catch (Dali::DaliException e) {
62227       {
62228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62229       };
62230     } catch (...) {
62231       {
62232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62233       };
62234     }
62235   }
62236
62237 }
62238
62239
62240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62242
62243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62244   {
62245     try {
62246       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62247     } catch (std::out_of_range& e) {
62248       {
62249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62250       };
62251     } catch (std::exception& e) {
62252       {
62253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62254       };
62255     } catch (Dali::DaliException e) {
62256       {
62257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62258       };
62259     } catch (...) {
62260       {
62261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62262       };
62263     }
62264   }
62265
62266 }
62267
62268
62269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62270   void * jresult ;
62271   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62272   Dali::Actor arg2 ;
62273   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62274   bool arg4 ;
62275   Dali::Actor *argp2 ;
62276   Dali::Actor result;
62277
62278   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62279   argp2 = (Dali::Actor *)jarg2;
62280   if (!argp2) {
62281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62282     return 0;
62283   }
62284   arg2 = *argp2;
62285   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62286   arg4 = jarg4 ? true : false;
62287   {
62288     try {
62289       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62290     } catch (std::out_of_range& e) {
62291       {
62292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62293       };
62294     } catch (std::exception& e) {
62295       {
62296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62297       };
62298     } catch (Dali::DaliException e) {
62299       {
62300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62301       };
62302     } catch (...) {
62303       {
62304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62305       };
62306     }
62307   }
62308
62309   jresult = new Dali::Actor((const Dali::Actor &)result);
62310   return jresult;
62311 }
62312
62313
62314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62315   void * jresult ;
62316   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62317   Dali::Actor arg2 ;
62318   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62319   bool arg4 ;
62320   Dali::Actor *argp2 ;
62321   Dali::Actor result;
62322
62323   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62324   argp2 = (Dali::Actor *)jarg2;
62325   if (!argp2) {
62326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62327     return 0;
62328   }
62329   arg2 = *argp2;
62330   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62331   arg4 = jarg4 ? true : false;
62332   {
62333     try {
62334       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62335     } catch (std::out_of_range& e) {
62336       {
62337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62338       };
62339     } catch (std::exception& e) {
62340       {
62341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62342       };
62343     } catch (Dali::DaliException e) {
62344       {
62345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62346       };
62347     } catch (...) {
62348       {
62349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62350       };
62351     }
62352   }
62353
62354   jresult = new Dali::Actor((const Dali::Actor &)result);
62355   return jresult;
62356 }
62357
62358
62359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62361   Dali::Actor arg2 ;
62362   Dali::Actor *argp2 ;
62363
62364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62365   argp2 = (Dali::Actor *)jarg2;
62366   if (!argp2) {
62367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62368     return ;
62369   }
62370   arg2 = *argp2;
62371   {
62372     try {
62373       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62374     } catch (std::out_of_range& e) {
62375       {
62376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62377       };
62378     } catch (std::exception& e) {
62379       {
62380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62381       };
62382     } catch (Dali::DaliException e) {
62383       {
62384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62385       };
62386     } catch (...) {
62387       {
62388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62389       };
62390     }
62391   }
62392
62393 }
62394
62395
62396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62397   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62398   Dali::Actor arg2 ;
62399   Dali::Actor *argp2 ;
62400
62401   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62402   argp2 = (Dali::Actor *)jarg2;
62403   if (!argp2) {
62404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62405     return ;
62406   }
62407   arg2 = *argp2;
62408   {
62409     try {
62410       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62411     } catch (std::out_of_range& e) {
62412       {
62413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62414       };
62415     } catch (std::exception& e) {
62416       {
62417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62418       };
62419     } catch (Dali::DaliException e) {
62420       {
62421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62422       };
62423     } catch (...) {
62424       {
62425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62426       };
62427     }
62428   }
62429
62430 }
62431
62432
62433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62434   unsigned int jresult ;
62435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62436   bool result;
62437
62438   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62439   {
62440     try {
62441       result = (bool)(arg1)->OnKeyboardEnter();
62442     } catch (std::out_of_range& e) {
62443       {
62444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62445       };
62446     } catch (std::exception& e) {
62447       {
62448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62449       };
62450     } catch (Dali::DaliException e) {
62451       {
62452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62453       };
62454     } catch (...) {
62455       {
62456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62457       };
62458     }
62459   }
62460
62461   jresult = result;
62462   return jresult;
62463 }
62464
62465
62466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62467   unsigned int jresult ;
62468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62469   bool result;
62470
62471   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62472   {
62473     try {
62474       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62475     } catch (std::out_of_range& e) {
62476       {
62477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62478       };
62479     } catch (std::exception& e) {
62480       {
62481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62482       };
62483     } catch (Dali::DaliException e) {
62484       {
62485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62486       };
62487     } catch (...) {
62488       {
62489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62490       };
62491     }
62492   }
62493
62494   jresult = result;
62495   return jresult;
62496 }
62497
62498
62499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62501   Dali::PinchGesture *arg2 = 0 ;
62502
62503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62504   arg2 = (Dali::PinchGesture *)jarg2;
62505   if (!arg2) {
62506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62507     return ;
62508   }
62509   {
62510     try {
62511       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62512     } catch (std::out_of_range& e) {
62513       {
62514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62515       };
62516     } catch (std::exception& e) {
62517       {
62518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62519       };
62520     } catch (Dali::DaliException e) {
62521       {
62522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62523       };
62524     } catch (...) {
62525       {
62526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62527       };
62528     }
62529   }
62530
62531 }
62532
62533
62534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62535   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62536   Dali::PinchGesture *arg2 = 0 ;
62537
62538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62539   arg2 = (Dali::PinchGesture *)jarg2;
62540   if (!arg2) {
62541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62542     return ;
62543   }
62544   {
62545     try {
62546       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62547     } catch (std::out_of_range& e) {
62548       {
62549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62550       };
62551     } catch (std::exception& e) {
62552       {
62553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62554       };
62555     } catch (Dali::DaliException e) {
62556       {
62557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62558       };
62559     } catch (...) {
62560       {
62561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62562       };
62563     }
62564   }
62565
62566 }
62567
62568
62569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62571   Dali::PanGesture *arg2 = 0 ;
62572
62573   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62574   arg2 = (Dali::PanGesture *)jarg2;
62575   if (!arg2) {
62576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62577     return ;
62578   }
62579   {
62580     try {
62581       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62582     } catch (std::out_of_range& e) {
62583       {
62584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62585       };
62586     } catch (std::exception& e) {
62587       {
62588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62589       };
62590     } catch (Dali::DaliException e) {
62591       {
62592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62593       };
62594     } catch (...) {
62595       {
62596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62597       };
62598     }
62599   }
62600
62601 }
62602
62603
62604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62606   Dali::PanGesture *arg2 = 0 ;
62607
62608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62609   arg2 = (Dali::PanGesture *)jarg2;
62610   if (!arg2) {
62611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62612     return ;
62613   }
62614   {
62615     try {
62616       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62617     } catch (std::out_of_range& e) {
62618       {
62619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62620       };
62621     } catch (std::exception& e) {
62622       {
62623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62624       };
62625     } catch (Dali::DaliException e) {
62626       {
62627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62628       };
62629     } catch (...) {
62630       {
62631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62632       };
62633     }
62634   }
62635
62636 }
62637
62638
62639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62641   Dali::TapGesture *arg2 = 0 ;
62642
62643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62644   arg2 = (Dali::TapGesture *)jarg2;
62645   if (!arg2) {
62646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62647     return ;
62648   }
62649   {
62650     try {
62651       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62652     } catch (std::out_of_range& e) {
62653       {
62654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62655       };
62656     } catch (std::exception& e) {
62657       {
62658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62659       };
62660     } catch (Dali::DaliException e) {
62661       {
62662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62663       };
62664     } catch (...) {
62665       {
62666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62667       };
62668     }
62669   }
62670
62671 }
62672
62673
62674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62676   Dali::TapGesture *arg2 = 0 ;
62677
62678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62679   arg2 = (Dali::TapGesture *)jarg2;
62680   if (!arg2) {
62681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62682     return ;
62683   }
62684   {
62685     try {
62686       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62687     } catch (std::out_of_range& e) {
62688       {
62689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62690       };
62691     } catch (std::exception& e) {
62692       {
62693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62694       };
62695     } catch (Dali::DaliException e) {
62696       {
62697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62698       };
62699     } catch (...) {
62700       {
62701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62702       };
62703     }
62704   }
62705
62706 }
62707
62708
62709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62711   Dali::LongPressGesture *arg2 = 0 ;
62712
62713   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62714   arg2 = (Dali::LongPressGesture *)jarg2;
62715   if (!arg2) {
62716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62717     return ;
62718   }
62719   {
62720     try {
62721       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62722     } catch (std::out_of_range& e) {
62723       {
62724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62725       };
62726     } catch (std::exception& e) {
62727       {
62728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62729       };
62730     } catch (Dali::DaliException e) {
62731       {
62732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62733       };
62734     } catch (...) {
62735       {
62736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62737       };
62738     }
62739   }
62740
62741 }
62742
62743
62744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62746   Dali::LongPressGesture *arg2 = 0 ;
62747
62748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62749   arg2 = (Dali::LongPressGesture *)jarg2;
62750   if (!arg2) {
62751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62752     return ;
62753   }
62754   {
62755     try {
62756       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62757     } catch (std::out_of_range& e) {
62758       {
62759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62760       };
62761     } catch (std::exception& e) {
62762       {
62763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62764       };
62765     } catch (Dali::DaliException e) {
62766       {
62767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62768       };
62769     } catch (...) {
62770       {
62771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62772       };
62773     }
62774   }
62775
62776 }
62777
62778
62779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62780   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62781   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62782   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62783
62784   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62785   arg2 = (Dali::SlotObserver *)jarg2;
62786   arg3 = (Dali::CallbackBase *)jarg3;
62787   {
62788     try {
62789       (arg1)->SignalConnected(arg2,arg3);
62790     } catch (std::out_of_range& e) {
62791       {
62792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62793       };
62794     } catch (std::exception& e) {
62795       {
62796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62797       };
62798     } catch (Dali::DaliException e) {
62799       {
62800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62801       };
62802     } catch (...) {
62803       {
62804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62805       };
62806     }
62807   }
62808
62809 }
62810
62811
62812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62814   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62815   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62816
62817   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62818   arg2 = (Dali::SlotObserver *)jarg2;
62819   arg3 = (Dali::CallbackBase *)jarg3;
62820   {
62821     try {
62822       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62823     } catch (std::out_of_range& e) {
62824       {
62825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62826       };
62827     } catch (std::exception& e) {
62828       {
62829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62830       };
62831     } catch (Dali::DaliException e) {
62832       {
62833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62834       };
62835     } catch (...) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62838       };
62839     }
62840   }
62841
62842 }
62843
62844
62845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62846   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62847   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62848   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62849
62850   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62851   arg2 = (Dali::SlotObserver *)jarg2;
62852   arg3 = (Dali::CallbackBase *)jarg3;
62853   {
62854     try {
62855       (arg1)->SignalDisconnected(arg2,arg3);
62856     } catch (std::out_of_range& e) {
62857       {
62858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62859       };
62860     } catch (std::exception& e) {
62861       {
62862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62863       };
62864     } catch (Dali::DaliException e) {
62865       {
62866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62867       };
62868     } catch (...) {
62869       {
62870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62871       };
62872     }
62873   }
62874
62875 }
62876
62877
62878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62880   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62881   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62882
62883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62884   arg2 = (Dali::SlotObserver *)jarg2;
62885   arg3 = (Dali::CallbackBase *)jarg3;
62886   {
62887     try {
62888       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62889     } catch (std::out_of_range& e) {
62890       {
62891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62892       };
62893     } catch (std::exception& e) {
62894       {
62895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62896       };
62897     } catch (Dali::DaliException e) {
62898       {
62899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62900       };
62901     } catch (...) {
62902       {
62903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62904       };
62905     }
62906   }
62907
62908 }
62909
62910 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) {
62911   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62912   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62913   if (director) {
62914     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);
62915   }
62916 }
62917
62918
62919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62920   void * jresult ;
62921   Dali::Toolkit::Control *arg1 = 0 ;
62922   Dali::Toolkit::Internal::Control *result = 0 ;
62923
62924   arg1 = (Dali::Toolkit::Control *)jarg1;
62925   if (!arg1) {
62926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62927     return 0;
62928   }
62929   {
62930     try {
62931       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62932     } catch (std::out_of_range& e) {
62933       {
62934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62935       };
62936     } catch (std::exception& e) {
62937       {
62938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62939       };
62940     } catch (Dali::DaliException e) {
62941       {
62942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62943       };
62944     } catch (...) {
62945       {
62946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62947       };
62948     }
62949   }
62950
62951   jresult = (void *)result;
62952   return jresult;
62953 }
62954
62955
62956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62957   int jresult ;
62958   int result;
62959
62960   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62961   jresult = (int)result;
62962   return jresult;
62963 }
62964
62965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62966   int jresult ;
62967   int result;
62968
62969   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62970   jresult = (int)result;
62971   return jresult;
62972 }
62973
62974
62975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62976   int jresult ;
62977   int result;
62978
62979   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62980   jresult = (int)result;
62981   return jresult;
62982 }
62983
62984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
62985   int jresult ;
62986   int result;
62987
62988   result = (int)Dali::Toolkit::Control::Property::MARGIN;
62989   jresult = (int)result;
62990   return jresult;
62991 }
62992
62993
62994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
62995   int jresult ;
62996   int result;
62997
62998   result = (int)Dali::Toolkit::Control::Property::PADDING;
62999   jresult = (int)result;
63000   return jresult;
63001 }
63002
63003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
63004   int jresult ;
63005   int result;
63006
63007   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
63008   jresult = (int)result;
63009   return jresult;
63010 }
63011
63012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63013   void * jresult ;
63014   Dali::Toolkit::Control::Property *result = 0 ;
63015
63016   {
63017     try {
63018       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63019     } catch (std::out_of_range& e) {
63020       {
63021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63022       };
63023     } catch (std::exception& e) {
63024       {
63025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63026       };
63027     } catch (Dali::DaliException e) {
63028       {
63029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63030       };
63031     } catch (...) {
63032       {
63033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63034       };
63035     }
63036   }
63037
63038   jresult = (void *)result;
63039   return jresult;
63040 }
63041
63042
63043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63044   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63045
63046   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63047   {
63048     try {
63049       delete arg1;
63050     } catch (std::out_of_range& e) {
63051       {
63052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63053       };
63054     } catch (std::exception& e) {
63055       {
63056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63057       };
63058     } catch (Dali::DaliException e) {
63059       {
63060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63061       };
63062     } catch (...) {
63063       {
63064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63065       };
63066     }
63067   }
63068
63069 }
63070
63071
63072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63073   void * jresult ;
63074   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63075
63076   {
63077     try {
63078       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63079     } catch (std::out_of_range& e) {
63080       {
63081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63082       };
63083     } catch (std::exception& e) {
63084       {
63085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63086       };
63087     } catch (Dali::DaliException e) {
63088       {
63089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63090       };
63091     } catch (...) {
63092       {
63093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63094       };
63095     }
63096   }
63097
63098   jresult = (void *)result;
63099   return jresult;
63100 }
63101
63102
63103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63104   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63105
63106   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63107   {
63108     try {
63109       delete arg1;
63110     } catch (std::out_of_range& e) {
63111       {
63112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63113       };
63114     } catch (std::exception& e) {
63115       {
63116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63117       };
63118     } catch (Dali::DaliException e) {
63119       {
63120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63121       };
63122     } catch (...) {
63123       {
63124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63125       };
63126     }
63127   }
63128
63129 }
63130
63131
63132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63133   void * jresult ;
63134   Dali::Toolkit::Control result;
63135
63136   {
63137     try {
63138       result = Dali::Toolkit::Control::New();
63139     } catch (std::out_of_range& e) {
63140       {
63141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63142       };
63143     } catch (std::exception& e) {
63144       {
63145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63146       };
63147     } catch (Dali::DaliException e) {
63148       {
63149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63150       };
63151     } catch (...) {
63152       {
63153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63154       };
63155     }
63156   }
63157
63158   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63159   return jresult;
63160 }
63161
63162
63163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63164   void * jresult ;
63165   Dali::Toolkit::Control *result = 0 ;
63166
63167   {
63168     try {
63169       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63170     } catch (std::out_of_range& e) {
63171       {
63172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63173       };
63174     } catch (std::exception& e) {
63175       {
63176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63177       };
63178     } catch (Dali::DaliException e) {
63179       {
63180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63181       };
63182     } catch (...) {
63183       {
63184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63185       };
63186     }
63187   }
63188
63189   jresult = (void *)result;
63190   return jresult;
63191 }
63192
63193
63194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63195   void * jresult ;
63196   Dali::Toolkit::Control *arg1 = 0 ;
63197   Dali::Toolkit::Control *result = 0 ;
63198
63199   arg1 = (Dali::Toolkit::Control *)jarg1;
63200   if (!arg1) {
63201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63202     return 0;
63203   }
63204   {
63205     try {
63206       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63207     } catch (std::out_of_range& e) {
63208       {
63209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63210       };
63211     } catch (std::exception& e) {
63212       {
63213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63214       };
63215     } catch (Dali::DaliException e) {
63216       {
63217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63218       };
63219     } catch (...) {
63220       {
63221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63222       };
63223     }
63224   }
63225
63226   jresult = (void *)result;
63227   return jresult;
63228 }
63229
63230
63231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63232   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63233
63234   arg1 = (Dali::Toolkit::Control *)jarg1;
63235   {
63236     try {
63237       delete arg1;
63238     } catch (std::out_of_range& e) {
63239       {
63240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63241       };
63242     } catch (std::exception& e) {
63243       {
63244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63245       };
63246     } catch (Dali::DaliException e) {
63247       {
63248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63249       };
63250     } catch (...) {
63251       {
63252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63253       };
63254     }
63255   }
63256
63257 }
63258
63259
63260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63261   void * jresult ;
63262   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63263   Dali::Toolkit::Control *arg2 = 0 ;
63264   Dali::Toolkit::Control *result = 0 ;
63265
63266   arg1 = (Dali::Toolkit::Control *)jarg1;
63267   arg2 = (Dali::Toolkit::Control *)jarg2;
63268   if (!arg2) {
63269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63270     return 0;
63271   }
63272   {
63273     try {
63274       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63275     } catch (std::out_of_range& e) {
63276       {
63277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63278       };
63279     } catch (std::exception& e) {
63280       {
63281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63282       };
63283     } catch (Dali::DaliException e) {
63284       {
63285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63286       };
63287     } catch (...) {
63288       {
63289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63290       };
63291     }
63292   }
63293
63294   jresult = (void *)result;
63295   return jresult;
63296 }
63297
63298
63299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63300   void * jresult ;
63301   Dali::BaseHandle arg1 ;
63302   Dali::BaseHandle *argp1 ;
63303   Dali::Toolkit::Control result;
63304
63305   argp1 = (Dali::BaseHandle *)jarg1;
63306   if (!argp1) {
63307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63308     return 0;
63309   }
63310   arg1 = *argp1;
63311   {
63312     try {
63313       result = Dali::Toolkit::Control::DownCast(arg1);
63314     } catch (std::out_of_range& e) {
63315       {
63316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63317       };
63318     } catch (std::exception& e) {
63319       {
63320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63321       };
63322     } catch (Dali::DaliException e) {
63323       {
63324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63325       };
63326     } catch (...) {
63327       {
63328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63329       };
63330     }
63331   }
63332
63333   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63334   return jresult;
63335 }
63336
63337
63338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63339   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63340
63341   arg1 = (Dali::Toolkit::Control *)jarg1;
63342   {
63343     try {
63344       (arg1)->SetKeyInputFocus();
63345     } catch (std::out_of_range& e) {
63346       {
63347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63348       };
63349     } catch (std::exception& e) {
63350       {
63351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63352       };
63353     } catch (Dali::DaliException e) {
63354       {
63355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63356       };
63357     } catch (...) {
63358       {
63359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63360       };
63361     }
63362   }
63363
63364 }
63365
63366
63367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63368   unsigned int jresult ;
63369   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63370   bool result;
63371
63372   arg1 = (Dali::Toolkit::Control *)jarg1;
63373   {
63374     try {
63375       result = (bool)(arg1)->HasKeyInputFocus();
63376     } catch (std::out_of_range& e) {
63377       {
63378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63379       };
63380     } catch (std::exception& e) {
63381       {
63382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63383       };
63384     } catch (Dali::DaliException e) {
63385       {
63386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63387       };
63388     } catch (...) {
63389       {
63390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63391       };
63392     }
63393   }
63394
63395   jresult = result;
63396   return jresult;
63397 }
63398
63399
63400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63401   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63402
63403   arg1 = (Dali::Toolkit::Control *)jarg1;
63404   {
63405     try {
63406       (arg1)->ClearKeyInputFocus();
63407     } catch (std::out_of_range& e) {
63408       {
63409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63410       };
63411     } catch (std::exception& e) {
63412       {
63413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63414       };
63415     } catch (Dali::DaliException e) {
63416       {
63417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63418       };
63419     } catch (...) {
63420       {
63421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63422       };
63423     }
63424   }
63425
63426 }
63427
63428
63429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63430   void * jresult ;
63431   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63432   Dali::PinchGestureDetector result;
63433
63434   arg1 = (Dali::Toolkit::Control *)jarg1;
63435   {
63436     try {
63437       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63438     } catch (std::out_of_range& e) {
63439       {
63440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63441       };
63442     } catch (std::exception& e) {
63443       {
63444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63445       };
63446     } catch (Dali::DaliException e) {
63447       {
63448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63449       };
63450     } catch (...) {
63451       {
63452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63453       };
63454     }
63455   }
63456
63457   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63458   return jresult;
63459 }
63460
63461
63462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63463   void * jresult ;
63464   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63465   Dali::PanGestureDetector result;
63466
63467   arg1 = (Dali::Toolkit::Control *)jarg1;
63468   {
63469     try {
63470       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63471     } catch (std::out_of_range& e) {
63472       {
63473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63474       };
63475     } catch (std::exception& e) {
63476       {
63477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63478       };
63479     } catch (Dali::DaliException e) {
63480       {
63481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63482       };
63483     } catch (...) {
63484       {
63485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63486       };
63487     }
63488   }
63489
63490   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63491   return jresult;
63492 }
63493
63494
63495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63496   void * jresult ;
63497   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63498   Dali::TapGestureDetector result;
63499
63500   arg1 = (Dali::Toolkit::Control *)jarg1;
63501   {
63502     try {
63503       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63504     } catch (std::out_of_range& e) {
63505       {
63506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63507       };
63508     } catch (std::exception& e) {
63509       {
63510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63511       };
63512     } catch (Dali::DaliException e) {
63513       {
63514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63515       };
63516     } catch (...) {
63517       {
63518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63519       };
63520     }
63521   }
63522
63523   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63524   return jresult;
63525 }
63526
63527
63528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63529   void * jresult ;
63530   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63531   Dali::LongPressGestureDetector result;
63532
63533   arg1 = (Dali::Toolkit::Control *)jarg1;
63534   {
63535     try {
63536       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63537     } catch (std::out_of_range& e) {
63538       {
63539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63540       };
63541     } catch (std::exception& e) {
63542       {
63543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63544       };
63545     } catch (Dali::DaliException e) {
63546       {
63547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63548       };
63549     } catch (...) {
63550       {
63551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63552       };
63553     }
63554   }
63555
63556   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63557   return jresult;
63558 }
63559
63560
63561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63562   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63563   std::string *arg2 = 0 ;
63564
63565   arg1 = (Dali::Toolkit::Control *)jarg1;
63566   if (!jarg2) {
63567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63568     return ;
63569   }
63570   std::string arg2_str(jarg2);
63571   arg2 = &arg2_str;
63572   {
63573     try {
63574       (arg1)->SetStyleName((std::string const &)*arg2);
63575     } catch (std::out_of_range& e) {
63576       {
63577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63578       };
63579     } catch (std::exception& e) {
63580       {
63581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63582       };
63583     } catch (Dali::DaliException e) {
63584       {
63585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63586       };
63587     } catch (...) {
63588       {
63589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63590       };
63591     }
63592   }
63593
63594
63595   //argout typemap for const std::string&
63596
63597 }
63598
63599
63600 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63601   char * jresult ;
63602   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63603   std::string *result = 0 ;
63604
63605   arg1 = (Dali::Toolkit::Control *)jarg1;
63606   {
63607     try {
63608       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63609     } catch (std::out_of_range& e) {
63610       {
63611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63612       };
63613     } catch (std::exception& e) {
63614       {
63615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63616       };
63617     } catch (Dali::DaliException e) {
63618       {
63619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63620       };
63621     } catch (...) {
63622       {
63623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63624       };
63625     }
63626   }
63627
63628   jresult = SWIG_csharp_string_callback(result->c_str());
63629   return jresult;
63630 }
63631
63632
63633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63634   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63635   Dali::Vector4 *arg2 = 0 ;
63636
63637   arg1 = (Dali::Toolkit::Control *)jarg1;
63638   arg2 = (Dali::Vector4 *)jarg2;
63639   if (!arg2) {
63640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63641     return ;
63642   }
63643   {
63644     try {
63645       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63646     } catch (std::out_of_range& e) {
63647       {
63648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63649       };
63650     } catch (std::exception& e) {
63651       {
63652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63653       };
63654     } catch (Dali::DaliException e) {
63655       {
63656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63657       };
63658     } catch (...) {
63659       {
63660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63661       };
63662     }
63663   }
63664
63665 }
63666
63667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63668   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63669
63670   arg1 = (Dali::Toolkit::Control *)jarg1;
63671   {
63672     try {
63673       (arg1)->ClearBackground();
63674     } catch (std::out_of_range& e) {
63675       {
63676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63677       };
63678     } catch (std::exception& e) {
63679       {
63680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63681       };
63682     } catch (Dali::DaliException e) {
63683       {
63684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63685       };
63686     } catch (...) {
63687       {
63688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63689       };
63690     }
63691   }
63692
63693 }
63694
63695
63696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63697   void * jresult ;
63698   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63699   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63700
63701   arg1 = (Dali::Toolkit::Control *)jarg1;
63702   {
63703     try {
63704       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63705     } catch (std::out_of_range& e) {
63706       {
63707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63708       };
63709     } catch (std::exception& e) {
63710       {
63711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63712       };
63713     } catch (Dali::DaliException e) {
63714       {
63715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63716       };
63717     } catch (...) {
63718       {
63719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63720       };
63721     }
63722   }
63723
63724   jresult = (void *)result;
63725   return jresult;
63726 }
63727
63728
63729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63730   void * jresult ;
63731   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63732   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63733
63734   arg1 = (Dali::Toolkit::Control *)jarg1;
63735   {
63736     try {
63737       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63738     } catch (std::out_of_range& e) {
63739       {
63740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63741       };
63742     } catch (std::exception& e) {
63743       {
63744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63745       };
63746     } catch (Dali::DaliException e) {
63747       {
63748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63749       };
63750     } catch (...) {
63751       {
63752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63753       };
63754     }
63755   }
63756
63757   jresult = (void *)result;
63758   return jresult;
63759 }
63760
63761
63762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63763   void * jresult ;
63764   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63765   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63766
63767   arg1 = (Dali::Toolkit::Control *)jarg1;
63768   {
63769     try {
63770       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63771     } catch (std::out_of_range& e) {
63772       {
63773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63774       };
63775     } catch (std::exception& e) {
63776       {
63777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63778       };
63779     } catch (Dali::DaliException e) {
63780       {
63781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63782       };
63783     } catch (...) {
63784       {
63785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63786       };
63787     }
63788   }
63789
63790   jresult = (void *)result;
63791   return jresult;
63792 }
63793
63794
63795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63796   void * jresult ;
63797   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63798   Dali::Toolkit::Control *result = 0 ;
63799
63800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63801   if (!arg1) {
63802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63803     return 0;
63804   }
63805   {
63806     try {
63807       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63808     } catch (std::out_of_range& e) {
63809       {
63810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63811       };
63812     } catch (std::exception& e) {
63813       {
63814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63815       };
63816     } catch (Dali::DaliException e) {
63817       {
63818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63819       };
63820     } catch (...) {
63821       {
63822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63823       };
63824     }
63825   }
63826
63827   jresult = (void *)result;
63828   return jresult;
63829 }
63830
63831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
63832 {
63833   int jresult;
63834   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63835   arg1 = (Dali::Toolkit::Control *)jarg1;
63836
63837   if (!arg1) {
63838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63839     return 0;
63840   }
63841
63842   Dali::Property::Index arg2 = 0 ;
63843   arg2 = (Dali::Property::Index)jarg2;
63844
63845   Toolkit::Visual::ResourceStatus result;
63846   {
63847     try {
63848       result = arg1->GetVisualResourceStatus(arg2);
63849     } catch (std::out_of_range& e) {
63850       {
63851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63852       };
63853     } catch (std::exception& e) {
63854       {
63855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63856       };
63857     } catch (...) {
63858       {
63859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63860       };
63861     }
63862   }
63863   jresult = (int)(result);
63864   return jresult;
63865 }
63866
63867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
63868 {
63869   void * jresult;
63870   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63871   arg1 = (Dali::Toolkit::Control *)jarg1;
63872
63873   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
63874
63875   Dali::Toolkit::TransitionData *arg2 = 0 ;
63876   Dali::Animation result;
63877
63878   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
63879   if (!arg2) {
63880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
63881     return 0;
63882   }
63883   {
63884     try {
63885       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
63886     } catch (std::out_of_range& e) {
63887       {
63888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63889       };
63890     } catch (std::exception& e) {
63891       {
63892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63893       };
63894     } catch (Dali::DaliException e) {
63895       {
63896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63897       };
63898     } catch (...) {
63899       {
63900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63901       };
63902     }
63903   }
63904
63905   jresult = new Dali::Animation((const Dali::Animation &)result);
63906   return jresult;
63907 }
63908
63909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
63910 {
63911   Dali::Toolkit::Control arg1;
63912   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
63913
63914   if (!argp1) {
63915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63916   }
63917   arg1 = *argp1;
63918
63919   Dali::Property::Index arg2 = 0 ;
63920   arg2 = (Dali::Property::Index)jarg2;
63921
63922   Dali::Property::Index arg3 = 0 ;
63923   arg3 = (Dali::Property::Index)jarg3;
63924
63925   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
63926
63927   {
63928     try {
63929       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
63930     } catch (std::out_of_range& e) {
63931       {
63932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63933       };
63934     } catch (std::exception& e) {
63935       {
63936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63937       };
63938     } catch (...) {
63939       {
63940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63941       };
63942     }
63943   }
63944
63945
63946 }
63947
63948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
63949   void * jresult ;
63950   Dali::Toolkit::Control *arg1 = 0 ;
63951   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
63952
63953   arg1 = (Dali::Toolkit::Control *)jarg1;
63954   if (!arg1) {
63955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63956     return 0;
63957   }
63958   {
63959     try {
63960       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
63961     } catch (std::out_of_range& e) {
63962       {
63963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63964       };
63965     } catch (std::exception& e) {
63966       {
63967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63968       };
63969     } catch (Dali::DaliException e) {
63970       {
63971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63972       };
63973     } catch (...) {
63974       {
63975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63976       };
63977     }
63978   }
63979
63980   jresult = (void *)result;
63981   return jresult;
63982 }
63983
63984
63985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
63986   unsigned int jresult ;
63987   Dali::Toolkit::Control *arg1 = 0 ;
63988   bool result;
63989
63990   arg1 = (Dali::Toolkit::Control *)jarg1;
63991   if (!arg1) {
63992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63993     return 0;
63994   }
63995   {
63996     try {
63997       result = (bool)arg1->IsResourceReady();
63998     } catch (std::out_of_range& e) {
63999       {
64000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64001       };
64002     } catch (std::exception& e) {
64003       {
64004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64005       };
64006     } catch (Dali::DaliException e) {
64007       {
64008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64009       };
64010     } catch (...) {
64011       {
64012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64013       };
64014     }
64015   }
64016
64017   jresult = result;
64018   return jresult;
64019 }
64020
64021
64022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64023   void * jresult ;
64024   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64025
64026   {
64027     try {
64028       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64029     } catch (std::out_of_range& e) {
64030       {
64031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64032       };
64033     } catch (std::exception& e) {
64034       {
64035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64036       };
64037     } catch (Dali::DaliException e) {
64038       {
64039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64040       };
64041     } catch (...) {
64042       {
64043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64044       };
64045     }
64046   }
64047
64048   jresult = (void *)result;
64049   return jresult;
64050 }
64051
64052
64053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64054   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64055
64056   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64057   {
64058     try {
64059       delete arg1;
64060     } catch (std::out_of_range& e) {
64061       {
64062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64063       };
64064     } catch (std::exception& e) {
64065       {
64066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64067       };
64068     } catch (Dali::DaliException e) {
64069       {
64070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64071       };
64072     } catch (...) {
64073       {
64074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64075       };
64076     }
64077   }
64078
64079 }
64080
64081
64082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64083   void * jresult ;
64084   Dali::Toolkit::KeyInputFocusManager result;
64085
64086   {
64087     try {
64088       result = Dali::Toolkit::KeyInputFocusManager::Get();
64089     } catch (std::out_of_range& e) {
64090       {
64091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64092       };
64093     } catch (std::exception& e) {
64094       {
64095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64096       };
64097     } catch (Dali::DaliException e) {
64098       {
64099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64100       };
64101     } catch (...) {
64102       {
64103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64104       };
64105     }
64106   }
64107
64108   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64109   return jresult;
64110 }
64111
64112
64113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64114   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64115   Dali::Toolkit::Control arg2 ;
64116   Dali::Toolkit::Control *argp2 ;
64117
64118   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64119   argp2 = (Dali::Toolkit::Control *)jarg2;
64120   if (!argp2) {
64121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64122     return ;
64123   }
64124   arg2 = *argp2;
64125   {
64126     try {
64127       (arg1)->SetFocus(arg2);
64128     } catch (std::out_of_range& e) {
64129       {
64130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64131       };
64132     } catch (std::exception& e) {
64133       {
64134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64135       };
64136     } catch (Dali::DaliException e) {
64137       {
64138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64139       };
64140     } catch (...) {
64141       {
64142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64143       };
64144     }
64145   }
64146
64147 }
64148
64149
64150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64151   void * jresult ;
64152   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64153   Dali::Toolkit::Control result;
64154
64155   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64156   {
64157     try {
64158       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64159     } catch (std::out_of_range& e) {
64160       {
64161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64162       };
64163     } catch (std::exception& e) {
64164       {
64165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64166       };
64167     } catch (Dali::DaliException e) {
64168       {
64169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64170       };
64171     } catch (...) {
64172       {
64173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64174       };
64175     }
64176   }
64177
64178   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64179   return jresult;
64180 }
64181
64182
64183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64184   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64185   Dali::Toolkit::Control arg2 ;
64186   Dali::Toolkit::Control *argp2 ;
64187
64188   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64189   argp2 = (Dali::Toolkit::Control *)jarg2;
64190   if (!argp2) {
64191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64192     return ;
64193   }
64194   arg2 = *argp2;
64195   {
64196     try {
64197       (arg1)->RemoveFocus(arg2);
64198     } catch (std::out_of_range& e) {
64199       {
64200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64201       };
64202     } catch (std::exception& e) {
64203       {
64204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64205       };
64206     } catch (Dali::DaliException e) {
64207       {
64208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64209       };
64210     } catch (...) {
64211       {
64212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64213       };
64214     }
64215   }
64216
64217 }
64218
64219
64220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64221   void * jresult ;
64222   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64223   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64224
64225   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64226   {
64227     try {
64228       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64229     } catch (std::out_of_range& e) {
64230       {
64231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64232       };
64233     } catch (std::exception& e) {
64234       {
64235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64236       };
64237     } catch (Dali::DaliException e) {
64238       {
64239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64240       };
64241     } catch (...) {
64242       {
64243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64244       };
64245     }
64246   }
64247
64248   jresult = (void *)result;
64249   return jresult;
64250 }
64251
64252
64253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64254   void * jresult ;
64255   Dali::Toolkit::Alignment::Padding *result = 0 ;
64256
64257   {
64258     try {
64259       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64260     } catch (std::out_of_range& e) {
64261       {
64262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64263       };
64264     } catch (std::exception& e) {
64265       {
64266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64267       };
64268     } catch (Dali::DaliException e) {
64269       {
64270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64271       };
64272     } catch (...) {
64273       {
64274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64275       };
64276     }
64277   }
64278
64279   jresult = (void *)result;
64280   return jresult;
64281 }
64282
64283
64284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64285   void * jresult ;
64286   float arg1 ;
64287   float arg2 ;
64288   float arg3 ;
64289   float arg4 ;
64290   Dali::Toolkit::Alignment::Padding *result = 0 ;
64291
64292   arg1 = (float)jarg1;
64293   arg2 = (float)jarg2;
64294   arg3 = (float)jarg3;
64295   arg4 = (float)jarg4;
64296   {
64297     try {
64298       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64299     } catch (std::out_of_range& e) {
64300       {
64301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64302       };
64303     } catch (std::exception& e) {
64304       {
64305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64306       };
64307     } catch (Dali::DaliException e) {
64308       {
64309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64310       };
64311     } catch (...) {
64312       {
64313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64314       };
64315     }
64316   }
64317
64318   jresult = (void *)result;
64319   return jresult;
64320 }
64321
64322
64323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64324   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64325   float arg2 ;
64326
64327   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64328   arg2 = (float)jarg2;
64329   if (arg1) (arg1)->left = arg2;
64330 }
64331
64332
64333 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64334   float jresult ;
64335   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64336   float result;
64337
64338   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64339   result = (float) ((arg1)->left);
64340   jresult = result;
64341   return jresult;
64342 }
64343
64344
64345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64346   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64347   float arg2 ;
64348
64349   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64350   arg2 = (float)jarg2;
64351   if (arg1) (arg1)->right = arg2;
64352 }
64353
64354
64355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64356   float jresult ;
64357   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64358   float result;
64359
64360   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64361   result = (float) ((arg1)->right);
64362   jresult = result;
64363   return jresult;
64364 }
64365
64366
64367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64368   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64369   float arg2 ;
64370
64371   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64372   arg2 = (float)jarg2;
64373   if (arg1) (arg1)->top = arg2;
64374 }
64375
64376
64377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64378   float jresult ;
64379   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64380   float result;
64381
64382   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64383   result = (float) ((arg1)->top);
64384   jresult = result;
64385   return jresult;
64386 }
64387
64388
64389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64390   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64391   float arg2 ;
64392
64393   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64394   arg2 = (float)jarg2;
64395   if (arg1) (arg1)->bottom = arg2;
64396 }
64397
64398
64399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64400   float jresult ;
64401   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64402   float result;
64403
64404   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64405   result = (float) ((arg1)->bottom);
64406   jresult = result;
64407   return jresult;
64408 }
64409
64410
64411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64412   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64413
64414   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64415   {
64416     try {
64417       delete arg1;
64418     } catch (std::out_of_range& e) {
64419       {
64420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64421       };
64422     } catch (std::exception& e) {
64423       {
64424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64425       };
64426     } catch (Dali::DaliException e) {
64427       {
64428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64429       };
64430     } catch (...) {
64431       {
64432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64433       };
64434     }
64435   }
64436
64437 }
64438
64439
64440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64441   void * jresult ;
64442   Dali::Toolkit::Alignment *result = 0 ;
64443
64444   {
64445     try {
64446       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64447     } catch (std::out_of_range& e) {
64448       {
64449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64450       };
64451     } catch (std::exception& e) {
64452       {
64453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64454       };
64455     } catch (Dali::DaliException e) {
64456       {
64457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64458       };
64459     } catch (...) {
64460       {
64461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64462       };
64463     }
64464   }
64465
64466   jresult = (void *)result;
64467   return jresult;
64468 }
64469
64470
64471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64472   void * jresult ;
64473   Dali::Toolkit::Alignment::Type arg1 ;
64474   Dali::Toolkit::Alignment::Type arg2 ;
64475   Dali::Toolkit::Alignment result;
64476
64477   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64478   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64479   {
64480     try {
64481       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64482     } catch (std::out_of_range& e) {
64483       {
64484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64485       };
64486     } catch (std::exception& e) {
64487       {
64488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64489       };
64490     } catch (Dali::DaliException e) {
64491       {
64492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64493       };
64494     } catch (...) {
64495       {
64496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64497       };
64498     }
64499   }
64500
64501   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64502   return jresult;
64503 }
64504
64505
64506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64507   void * jresult ;
64508   Dali::Toolkit::Alignment::Type arg1 ;
64509   Dali::Toolkit::Alignment result;
64510
64511   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64512   {
64513     try {
64514       result = Dali::Toolkit::Alignment::New(arg1);
64515     } catch (std::out_of_range& e) {
64516       {
64517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64518       };
64519     } catch (std::exception& e) {
64520       {
64521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64522       };
64523     } catch (Dali::DaliException e) {
64524       {
64525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64526       };
64527     } catch (...) {
64528       {
64529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64530       };
64531     }
64532   }
64533
64534   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64535   return jresult;
64536 }
64537
64538
64539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64540   void * jresult ;
64541   Dali::Toolkit::Alignment result;
64542
64543   {
64544     try {
64545       result = Dali::Toolkit::Alignment::New();
64546     } catch (std::out_of_range& e) {
64547       {
64548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64549       };
64550     } catch (std::exception& e) {
64551       {
64552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64553       };
64554     } catch (Dali::DaliException e) {
64555       {
64556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64557       };
64558     } catch (...) {
64559       {
64560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64561       };
64562     }
64563   }
64564
64565   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64566   return jresult;
64567 }
64568
64569
64570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64571   void * jresult ;
64572   Dali::Toolkit::Alignment *arg1 = 0 ;
64573   Dali::Toolkit::Alignment *result = 0 ;
64574
64575   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64576   if (!arg1) {
64577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64578     return 0;
64579   }
64580   {
64581     try {
64582       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64583     } catch (std::out_of_range& e) {
64584       {
64585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64586       };
64587     } catch (std::exception& e) {
64588       {
64589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64590       };
64591     } catch (Dali::DaliException e) {
64592       {
64593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64594       };
64595     } catch (...) {
64596       {
64597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64598       };
64599     }
64600   }
64601
64602   jresult = (void *)result;
64603   return jresult;
64604 }
64605
64606
64607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64608   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64609
64610   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64611   {
64612     try {
64613       delete arg1;
64614     } catch (std::out_of_range& e) {
64615       {
64616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64617       };
64618     } catch (std::exception& e) {
64619       {
64620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64621       };
64622     } catch (Dali::DaliException e) {
64623       {
64624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64625       };
64626     } catch (...) {
64627       {
64628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64629       };
64630     }
64631   }
64632
64633 }
64634
64635
64636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64637   void * jresult ;
64638   Dali::BaseHandle arg1 ;
64639   Dali::BaseHandle *argp1 ;
64640   Dali::Toolkit::Alignment result;
64641
64642   argp1 = (Dali::BaseHandle *)jarg1;
64643   if (!argp1) {
64644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64645     return 0;
64646   }
64647   arg1 = *argp1;
64648   {
64649     try {
64650       result = Dali::Toolkit::Alignment::DownCast(arg1);
64651     } catch (std::out_of_range& e) {
64652       {
64653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64654       };
64655     } catch (std::exception& e) {
64656       {
64657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64658       };
64659     } catch (Dali::DaliException e) {
64660       {
64661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64662       };
64663     } catch (...) {
64664       {
64665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64666       };
64667     }
64668   }
64669
64670   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64671   return jresult;
64672 }
64673
64674
64675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64676   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64677   Dali::Toolkit::Alignment::Type arg2 ;
64678
64679   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64680   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64681   {
64682     try {
64683       (arg1)->SetAlignmentType(arg2);
64684     } catch (std::out_of_range& e) {
64685       {
64686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64687       };
64688     } catch (std::exception& e) {
64689       {
64690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64691       };
64692     } catch (Dali::DaliException e) {
64693       {
64694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64695       };
64696     } catch (...) {
64697       {
64698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64699       };
64700     }
64701   }
64702
64703 }
64704
64705
64706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64707   int jresult ;
64708   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64709   Dali::Toolkit::Alignment::Type result;
64710
64711   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64712   {
64713     try {
64714       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64715     } catch (std::out_of_range& e) {
64716       {
64717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64718       };
64719     } catch (std::exception& e) {
64720       {
64721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64722       };
64723     } catch (Dali::DaliException e) {
64724       {
64725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64726       };
64727     } catch (...) {
64728       {
64729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64730       };
64731     }
64732   }
64733
64734   jresult = (int)result;
64735   return jresult;
64736 }
64737
64738
64739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64740   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64741   Dali::Toolkit::Alignment::Scaling arg2 ;
64742
64743   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64744   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64745   {
64746     try {
64747       (arg1)->SetScaling(arg2);
64748     } catch (std::out_of_range& e) {
64749       {
64750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64751       };
64752     } catch (std::exception& e) {
64753       {
64754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64755       };
64756     } catch (Dali::DaliException e) {
64757       {
64758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64759       };
64760     } catch (...) {
64761       {
64762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64763       };
64764     }
64765   }
64766
64767 }
64768
64769
64770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64771   int jresult ;
64772   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64773   Dali::Toolkit::Alignment::Scaling result;
64774
64775   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64776   {
64777     try {
64778       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64779     } catch (std::out_of_range& e) {
64780       {
64781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64782       };
64783     } catch (std::exception& e) {
64784       {
64785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64786       };
64787     } catch (Dali::DaliException e) {
64788       {
64789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64790       };
64791     } catch (...) {
64792       {
64793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64794       };
64795     }
64796   }
64797
64798   jresult = (int)result;
64799   return jresult;
64800 }
64801
64802
64803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64804   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64805   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64806
64807   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64808   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64809   if (!arg2) {
64810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64811     return ;
64812   }
64813   {
64814     try {
64815       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64816     } catch (std::out_of_range& e) {
64817       {
64818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64819       };
64820     } catch (std::exception& e) {
64821       {
64822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64823       };
64824     } catch (Dali::DaliException e) {
64825       {
64826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64827       };
64828     } catch (...) {
64829       {
64830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64831       };
64832     }
64833   }
64834
64835 }
64836
64837
64838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64839   void * jresult ;
64840   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64841   Dali::Toolkit::Alignment::Padding *result = 0 ;
64842
64843   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64844   {
64845     try {
64846       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64847     } catch (std::out_of_range& e) {
64848       {
64849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64850       };
64851     } catch (std::exception& e) {
64852       {
64853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64854       };
64855     } catch (Dali::DaliException e) {
64856       {
64857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64858       };
64859     } catch (...) {
64860       {
64861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64862       };
64863     }
64864   }
64865
64866   jresult = (void *)result;
64867   return jresult;
64868 }
64869
64870
64871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64872   void * jresult ;
64873   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64874   Dali::Toolkit::Alignment *arg2 = 0 ;
64875   Dali::Toolkit::Alignment *result = 0 ;
64876
64877   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64878   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64879   if (!arg2) {
64880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64881     return 0;
64882   }
64883   {
64884     try {
64885       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64886     } catch (std::out_of_range& e) {
64887       {
64888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64889       };
64890     } catch (std::exception& e) {
64891       {
64892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64893       };
64894     } catch (Dali::DaliException e) {
64895       {
64896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64897       };
64898     } catch (...) {
64899       {
64900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64901       };
64902     }
64903   }
64904
64905   jresult = (void *)result;
64906   return jresult;
64907 }
64908
64909
64910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64911   int jresult ;
64912   int result;
64913
64914   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64915   jresult = (int)result;
64916   return jresult;
64917 }
64918
64919
64920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64921   int jresult ;
64922   int result;
64923
64924   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64925   jresult = (int)result;
64926   return jresult;
64927 }
64928
64929
64930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64931   int jresult ;
64932   int result;
64933
64934   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64935   jresult = (int)result;
64936   return jresult;
64937 }
64938
64939
64940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64941   int jresult ;
64942   int result;
64943
64944   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64945   jresult = (int)result;
64946   return jresult;
64947 }
64948
64949
64950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64951   int jresult ;
64952   int result;
64953
64954   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64955   jresult = (int)result;
64956   return jresult;
64957 }
64958
64959
64960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64961   int jresult ;
64962   int result;
64963
64964   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64965   jresult = (int)result;
64966   return jresult;
64967 }
64968
64969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64970   int jresult ;
64971   int result;
64972
64973   result = (int)Dali::Toolkit::Button::Property::LABEL;
64974   jresult = (int)result;
64975   return jresult;
64976 }
64977
64978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64979   void * jresult ;
64980   Dali::Toolkit::Button::Property *result = 0 ;
64981
64982   {
64983     try {
64984       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64985     } catch (std::out_of_range& e) {
64986       {
64987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64988       };
64989     } catch (std::exception& e) {
64990       {
64991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64992       };
64993     } catch (Dali::DaliException e) {
64994       {
64995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64996       };
64997     } catch (...) {
64998       {
64999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65000       };
65001     }
65002   }
65003
65004   jresult = (void *)result;
65005   return jresult;
65006 }
65007
65008
65009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65010   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65011
65012   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65013   {
65014     try {
65015       delete arg1;
65016     } catch (std::out_of_range& e) {
65017       {
65018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65019       };
65020     } catch (std::exception& e) {
65021       {
65022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65023       };
65024     } catch (Dali::DaliException e) {
65025       {
65026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65027       };
65028     } catch (...) {
65029       {
65030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65031       };
65032     }
65033   }
65034
65035 }
65036
65037
65038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65039   void * jresult ;
65040   Dali::Toolkit::Button *result = 0 ;
65041
65042   {
65043     try {
65044       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65045     } catch (std::out_of_range& e) {
65046       {
65047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65048       };
65049     } catch (std::exception& e) {
65050       {
65051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65052       };
65053     } catch (Dali::DaliException e) {
65054       {
65055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65056       };
65057     } catch (...) {
65058       {
65059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65060       };
65061     }
65062   }
65063
65064   jresult = (void *)result;
65065   return jresult;
65066 }
65067
65068
65069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65070   void * jresult ;
65071   Dali::Toolkit::Button *arg1 = 0 ;
65072   Dali::Toolkit::Button *result = 0 ;
65073
65074   arg1 = (Dali::Toolkit::Button *)jarg1;
65075   if (!arg1) {
65076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65077     return 0;
65078   }
65079   {
65080     try {
65081       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65082     } catch (std::out_of_range& e) {
65083       {
65084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65085       };
65086     } catch (std::exception& e) {
65087       {
65088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65089       };
65090     } catch (Dali::DaliException e) {
65091       {
65092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65093       };
65094     } catch (...) {
65095       {
65096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65097       };
65098     }
65099   }
65100
65101   jresult = (void *)result;
65102   return jresult;
65103 }
65104
65105
65106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65107   void * jresult ;
65108   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65109   Dali::Toolkit::Button *arg2 = 0 ;
65110   Dali::Toolkit::Button *result = 0 ;
65111
65112   arg1 = (Dali::Toolkit::Button *)jarg1;
65113   arg2 = (Dali::Toolkit::Button *)jarg2;
65114   if (!arg2) {
65115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65116     return 0;
65117   }
65118   {
65119     try {
65120       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65121     } catch (std::out_of_range& e) {
65122       {
65123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65124       };
65125     } catch (std::exception& e) {
65126       {
65127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65128       };
65129     } catch (Dali::DaliException e) {
65130       {
65131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65132       };
65133     } catch (...) {
65134       {
65135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65136       };
65137     }
65138   }
65139
65140   jresult = (void *)result;
65141   return jresult;
65142 }
65143
65144
65145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65146   void * jresult ;
65147   Dali::BaseHandle arg1 ;
65148   Dali::BaseHandle *argp1 ;
65149   Dali::Toolkit::Button result;
65150
65151   argp1 = (Dali::BaseHandle *)jarg1;
65152   if (!argp1) {
65153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65154     return 0;
65155   }
65156   arg1 = *argp1;
65157   {
65158     try {
65159       result = Dali::Toolkit::Button::DownCast(arg1);
65160     } catch (std::out_of_range& e) {
65161       {
65162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65163       };
65164     } catch (std::exception& e) {
65165       {
65166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65167       };
65168     } catch (Dali::DaliException e) {
65169       {
65170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65171       };
65172     } catch (...) {
65173       {
65174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65175       };
65176     }
65177   }
65178
65179   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65180   return jresult;
65181 }
65182
65183
65184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65185   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65186
65187   arg1 = (Dali::Toolkit::Button *)jarg1;
65188   {
65189     try {
65190       delete arg1;
65191     } catch (std::out_of_range& e) {
65192       {
65193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65194       };
65195     } catch (std::exception& e) {
65196       {
65197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65198       };
65199     } catch (Dali::DaliException e) {
65200       {
65201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65202       };
65203     } catch (...) {
65204       {
65205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65206       };
65207     }
65208   }
65209
65210 }
65211
65212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65213   void * jresult ;
65214   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65215   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65216
65217   arg1 = (Dali::Toolkit::Button *)jarg1;
65218   {
65219     try {
65220       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65221     } catch (std::out_of_range& e) {
65222       {
65223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65224       };
65225     } catch (std::exception& e) {
65226       {
65227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65228       };
65229     } catch (Dali::DaliException e) {
65230       {
65231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65232       };
65233     } catch (...) {
65234       {
65235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65236       };
65237     }
65238   }
65239
65240   jresult = (void *)result;
65241   return jresult;
65242 }
65243
65244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65245   void * jresult ;
65246   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65247   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65248
65249   arg1 = (Dali::Toolkit::Button *)jarg1;
65250   {
65251     try {
65252       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65253     } catch (std::out_of_range& e) {
65254       {
65255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65256       };
65257     } catch (std::exception& e) {
65258       {
65259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65260       };
65261     } catch (Dali::DaliException e) {
65262       {
65263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65264       };
65265     } catch (...) {
65266       {
65267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65268       };
65269     }
65270   }
65271
65272   jresult = (void *)result;
65273   return jresult;
65274 }
65275
65276
65277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65278   void * jresult ;
65279   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65280   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65281
65282   arg1 = (Dali::Toolkit::Button *)jarg1;
65283   {
65284     try {
65285       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65286     } catch (std::out_of_range& e) {
65287       {
65288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65289       };
65290     } catch (std::exception& e) {
65291       {
65292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65293       };
65294     } catch (Dali::DaliException e) {
65295       {
65296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65297       };
65298     } catch (...) {
65299       {
65300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65301       };
65302     }
65303   }
65304
65305   jresult = (void *)result;
65306   return jresult;
65307 }
65308
65309
65310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65311   void * jresult ;
65312   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65313   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65314
65315   arg1 = (Dali::Toolkit::Button *)jarg1;
65316   {
65317     try {
65318       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65319     } catch (std::out_of_range& e) {
65320       {
65321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65322       };
65323     } catch (std::exception& e) {
65324       {
65325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65326       };
65327     } catch (Dali::DaliException e) {
65328       {
65329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65330       };
65331     } catch (...) {
65332       {
65333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65334       };
65335     }
65336   }
65337
65338   jresult = (void *)result;
65339   return jresult;
65340 }
65341
65342
65343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65344   void * jresult ;
65345   Dali::Toolkit::CheckBoxButton *result = 0 ;
65346
65347   {
65348     try {
65349       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65350     } catch (std::out_of_range& e) {
65351       {
65352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65353       };
65354     } catch (std::exception& e) {
65355       {
65356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65357       };
65358     } catch (Dali::DaliException e) {
65359       {
65360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65361       };
65362     } catch (...) {
65363       {
65364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65365       };
65366     }
65367   }
65368
65369   jresult = (void *)result;
65370   return jresult;
65371 }
65372
65373
65374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65375   void * jresult ;
65376   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65377   Dali::Toolkit::CheckBoxButton *result = 0 ;
65378
65379   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65380   if (!arg1) {
65381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65382     return 0;
65383   }
65384   {
65385     try {
65386       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65387     } catch (std::out_of_range& e) {
65388       {
65389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65390       };
65391     } catch (std::exception& e) {
65392       {
65393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65394       };
65395     } catch (Dali::DaliException e) {
65396       {
65397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65398       };
65399     } catch (...) {
65400       {
65401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65402       };
65403     }
65404   }
65405
65406   jresult = (void *)result;
65407   return jresult;
65408 }
65409
65410
65411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65412   void * jresult ;
65413   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65414   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65415   Dali::Toolkit::CheckBoxButton *result = 0 ;
65416
65417   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65418   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65419   if (!arg2) {
65420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65421     return 0;
65422   }
65423   {
65424     try {
65425       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65426     } catch (std::out_of_range& e) {
65427       {
65428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65429       };
65430     } catch (std::exception& e) {
65431       {
65432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65433       };
65434     } catch (Dali::DaliException e) {
65435       {
65436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65437       };
65438     } catch (...) {
65439       {
65440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65441       };
65442     }
65443   }
65444
65445   jresult = (void *)result;
65446   return jresult;
65447 }
65448
65449
65450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65451   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65452
65453   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65454   {
65455     try {
65456       delete arg1;
65457     } catch (std::out_of_range& e) {
65458       {
65459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65460       };
65461     } catch (std::exception& e) {
65462       {
65463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65464       };
65465     } catch (Dali::DaliException e) {
65466       {
65467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65468       };
65469     } catch (...) {
65470       {
65471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65472       };
65473     }
65474   }
65475
65476 }
65477
65478
65479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65480   void * jresult ;
65481   Dali::Toolkit::CheckBoxButton result;
65482
65483   {
65484     try {
65485       result = Dali::Toolkit::CheckBoxButton::New();
65486     } catch (std::out_of_range& e) {
65487       {
65488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65489       };
65490     } catch (std::exception& e) {
65491       {
65492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65493       };
65494     } catch (Dali::DaliException e) {
65495       {
65496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65497       };
65498     } catch (...) {
65499       {
65500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65501       };
65502     }
65503   }
65504
65505   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65506   return jresult;
65507 }
65508
65509
65510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65511   void * jresult ;
65512   Dali::BaseHandle arg1 ;
65513   Dali::BaseHandle *argp1 ;
65514   Dali::Toolkit::CheckBoxButton result;
65515
65516   argp1 = (Dali::BaseHandle *)jarg1;
65517   if (!argp1) {
65518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65519     return 0;
65520   }
65521   arg1 = *argp1;
65522   {
65523     try {
65524       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65525     } catch (std::out_of_range& e) {
65526       {
65527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65528       };
65529     } catch (std::exception& e) {
65530       {
65531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65532       };
65533     } catch (Dali::DaliException e) {
65534       {
65535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65536       };
65537     } catch (...) {
65538       {
65539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65540       };
65541     }
65542   }
65543
65544   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65545   return jresult;
65546 }
65547
65548
65549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65550   int jresult ;
65551   int result;
65552
65553   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65554   jresult = (int)result;
65555   return jresult;
65556 }
65557
65558
65559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65560   int jresult ;
65561   int result;
65562
65563   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65564   jresult = (int)result;
65565   return jresult;
65566 }
65567
65568
65569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65570   void * jresult ;
65571   Dali::Toolkit::PushButton::Property *result = 0 ;
65572
65573   {
65574     try {
65575       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65576     } catch (std::out_of_range& e) {
65577       {
65578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65579       };
65580     } catch (std::exception& e) {
65581       {
65582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65583       };
65584     } catch (Dali::DaliException e) {
65585       {
65586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65587       };
65588     } catch (...) {
65589       {
65590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65591       };
65592     }
65593   }
65594
65595   jresult = (void *)result;
65596   return jresult;
65597 }
65598
65599
65600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65601   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65602
65603   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65604   {
65605     try {
65606       delete arg1;
65607     } catch (std::out_of_range& e) {
65608       {
65609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65610       };
65611     } catch (std::exception& e) {
65612       {
65613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65614       };
65615     } catch (Dali::DaliException e) {
65616       {
65617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65618       };
65619     } catch (...) {
65620       {
65621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65622       };
65623     }
65624   }
65625
65626 }
65627
65628
65629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65630   void * jresult ;
65631   Dali::Toolkit::PushButton *result = 0 ;
65632
65633   {
65634     try {
65635       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65636     } catch (std::out_of_range& e) {
65637       {
65638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65639       };
65640     } catch (std::exception& e) {
65641       {
65642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65643       };
65644     } catch (Dali::DaliException e) {
65645       {
65646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65647       };
65648     } catch (...) {
65649       {
65650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65651       };
65652     }
65653   }
65654
65655   jresult = (void *)result;
65656   return jresult;
65657 }
65658
65659
65660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65661   void * jresult ;
65662   Dali::Toolkit::PushButton *arg1 = 0 ;
65663   Dali::Toolkit::PushButton *result = 0 ;
65664
65665   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65666   if (!arg1) {
65667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65668     return 0;
65669   }
65670   {
65671     try {
65672       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65673     } catch (std::out_of_range& e) {
65674       {
65675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65676       };
65677     } catch (std::exception& e) {
65678       {
65679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65680       };
65681     } catch (Dali::DaliException e) {
65682       {
65683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65684       };
65685     } catch (...) {
65686       {
65687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65688       };
65689     }
65690   }
65691
65692   jresult = (void *)result;
65693   return jresult;
65694 }
65695
65696
65697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65698   void * jresult ;
65699   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65700   Dali::Toolkit::PushButton *arg2 = 0 ;
65701   Dali::Toolkit::PushButton *result = 0 ;
65702
65703   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65704   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65705   if (!arg2) {
65706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65707     return 0;
65708   }
65709   {
65710     try {
65711       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65712     } catch (std::out_of_range& e) {
65713       {
65714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65715       };
65716     } catch (std::exception& e) {
65717       {
65718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65719       };
65720     } catch (Dali::DaliException e) {
65721       {
65722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65723       };
65724     } catch (...) {
65725       {
65726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65727       };
65728     }
65729   }
65730
65731   jresult = (void *)result;
65732   return jresult;
65733 }
65734
65735
65736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65737   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65738
65739   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65740   {
65741     try {
65742       delete arg1;
65743     } catch (std::out_of_range& e) {
65744       {
65745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65746       };
65747     } catch (std::exception& e) {
65748       {
65749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65750       };
65751     } catch (Dali::DaliException e) {
65752       {
65753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65754       };
65755     } catch (...) {
65756       {
65757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65758       };
65759     }
65760   }
65761
65762 }
65763
65764
65765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65766   void * jresult ;
65767   Dali::Toolkit::PushButton result;
65768
65769   {
65770     try {
65771       result = Dali::Toolkit::PushButton::New();
65772     } catch (std::out_of_range& e) {
65773       {
65774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65775       };
65776     } catch (std::exception& e) {
65777       {
65778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65779       };
65780     } catch (Dali::DaliException e) {
65781       {
65782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65783       };
65784     } catch (...) {
65785       {
65786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65787       };
65788     }
65789   }
65790
65791   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65792   return jresult;
65793 }
65794
65795
65796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65797   void * jresult ;
65798   Dali::BaseHandle arg1 ;
65799   Dali::BaseHandle *argp1 ;
65800   Dali::Toolkit::PushButton result;
65801
65802   argp1 = (Dali::BaseHandle *)jarg1;
65803   if (!argp1) {
65804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65805     return 0;
65806   }
65807   arg1 = *argp1;
65808   {
65809     try {
65810       result = Dali::Toolkit::PushButton::DownCast(arg1);
65811     } catch (std::out_of_range& e) {
65812       {
65813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65814       };
65815     } catch (std::exception& e) {
65816       {
65817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65818       };
65819     } catch (Dali::DaliException e) {
65820       {
65821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65822       };
65823     } catch (...) {
65824       {
65825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65826       };
65827     }
65828   }
65829
65830   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65831   return jresult;
65832 }
65833
65834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65835   void * jresult ;
65836   Dali::Toolkit::RadioButton *result = 0 ;
65837
65838   {
65839     try {
65840       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65841     } catch (std::out_of_range& e) {
65842       {
65843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65844       };
65845     } catch (std::exception& e) {
65846       {
65847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65848       };
65849     } catch (Dali::DaliException e) {
65850       {
65851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65852       };
65853     } catch (...) {
65854       {
65855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65856       };
65857     }
65858   }
65859
65860   jresult = (void *)result;
65861   return jresult;
65862 }
65863
65864
65865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65866   void * jresult ;
65867   Dali::Toolkit::RadioButton *arg1 = 0 ;
65868   Dali::Toolkit::RadioButton *result = 0 ;
65869
65870   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65871   if (!arg1) {
65872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65873     return 0;
65874   }
65875   {
65876     try {
65877       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65878     } catch (std::out_of_range& e) {
65879       {
65880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65881       };
65882     } catch (std::exception& e) {
65883       {
65884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65885       };
65886     } catch (Dali::DaliException e) {
65887       {
65888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65889       };
65890     } catch (...) {
65891       {
65892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65893       };
65894     }
65895   }
65896
65897   jresult = (void *)result;
65898   return jresult;
65899 }
65900
65901
65902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65903   void * jresult ;
65904   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65905   Dali::Toolkit::RadioButton *arg2 = 0 ;
65906   Dali::Toolkit::RadioButton *result = 0 ;
65907
65908   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65909   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65910   if (!arg2) {
65911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65912     return 0;
65913   }
65914   {
65915     try {
65916       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65917     } catch (std::out_of_range& e) {
65918       {
65919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65920       };
65921     } catch (std::exception& e) {
65922       {
65923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65924       };
65925     } catch (Dali::DaliException e) {
65926       {
65927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65928       };
65929     } catch (...) {
65930       {
65931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65932       };
65933     }
65934   }
65935
65936   jresult = (void *)result;
65937   return jresult;
65938 }
65939
65940
65941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65942   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65943
65944   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65945   {
65946     try {
65947       delete arg1;
65948     } catch (std::out_of_range& e) {
65949       {
65950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65951       };
65952     } catch (std::exception& e) {
65953       {
65954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65955       };
65956     } catch (Dali::DaliException e) {
65957       {
65958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65959       };
65960     } catch (...) {
65961       {
65962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65963       };
65964     }
65965   }
65966
65967 }
65968
65969
65970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65971   void * jresult ;
65972   Dali::Toolkit::RadioButton result;
65973
65974   {
65975     try {
65976       result = Dali::Toolkit::RadioButton::New();
65977     } catch (std::out_of_range& e) {
65978       {
65979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65980       };
65981     } catch (std::exception& e) {
65982       {
65983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65984       };
65985     } catch (Dali::DaliException e) {
65986       {
65987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65988       };
65989     } catch (...) {
65990       {
65991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65992       };
65993     }
65994   }
65995
65996   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65997   return jresult;
65998 }
65999
66000
66001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66002   void * jresult ;
66003   std::string *arg1 = 0 ;
66004   Dali::Toolkit::RadioButton result;
66005
66006   if (!jarg1) {
66007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66008     return 0;
66009   }
66010   std::string arg1_str(jarg1);
66011   arg1 = &arg1_str;
66012   {
66013     try {
66014       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66015     } catch (std::out_of_range& e) {
66016       {
66017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66018       };
66019     } catch (std::exception& e) {
66020       {
66021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66022       };
66023     } catch (Dali::DaliException e) {
66024       {
66025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66026       };
66027     } catch (...) {
66028       {
66029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66030       };
66031     }
66032   }
66033
66034   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66035
66036   //argout typemap for const std::string&
66037
66038   return jresult;
66039 }
66040
66041
66042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66043   void * jresult ;
66044   Dali::BaseHandle arg1 ;
66045   Dali::BaseHandle *argp1 ;
66046   Dali::Toolkit::RadioButton result;
66047
66048   argp1 = (Dali::BaseHandle *)jarg1;
66049   if (!argp1) {
66050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66051     return 0;
66052   }
66053   arg1 = *argp1;
66054   {
66055     try {
66056       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66057     } catch (std::out_of_range& e) {
66058       {
66059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66060       };
66061     } catch (std::exception& e) {
66062       {
66063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66064       };
66065     } catch (Dali::DaliException e) {
66066       {
66067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66068       };
66069     } catch (...) {
66070       {
66071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66072       };
66073     }
66074   }
66075
66076   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66077   return jresult;
66078 }
66079
66080
66081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66082   int jresult ;
66083   int result;
66084
66085   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66086   jresult = (int)result;
66087   return jresult;
66088 }
66089
66090
66091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66092   int jresult ;
66093   int result;
66094
66095   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66096   jresult = (int)result;
66097   return jresult;
66098 }
66099
66100
66101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66102   int jresult ;
66103   int result;
66104
66105   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66106   jresult = (int)result;
66107   return jresult;
66108 }
66109
66110
66111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66112   int jresult ;
66113   int result;
66114
66115   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66116   jresult = (int)result;
66117   return jresult;
66118 }
66119
66120
66121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66122   int jresult ;
66123   int result;
66124
66125   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66126   jresult = (int)result;
66127   return jresult;
66128 }
66129
66130
66131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66132   int jresult ;
66133   int result;
66134
66135   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66136   jresult = (int)result;
66137   return jresult;
66138 }
66139
66140
66141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66142   void * jresult ;
66143   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66144
66145   {
66146     try {
66147       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66148     } catch (std::out_of_range& e) {
66149       {
66150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66151       };
66152     } catch (std::exception& e) {
66153       {
66154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66155       };
66156     } catch (Dali::DaliException e) {
66157       {
66158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66159       };
66160     } catch (...) {
66161       {
66162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66163       };
66164     }
66165   }
66166
66167   jresult = (void *)result;
66168   return jresult;
66169 }
66170
66171
66172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66173   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66174
66175   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66176   {
66177     try {
66178       delete arg1;
66179     } catch (std::out_of_range& e) {
66180       {
66181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66182       };
66183     } catch (std::exception& e) {
66184       {
66185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66186       };
66187     } catch (Dali::DaliException e) {
66188       {
66189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66190       };
66191     } catch (...) {
66192       {
66193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66194       };
66195     }
66196   }
66197
66198 }
66199
66200
66201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66202   int jresult ;
66203   int result;
66204
66205   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66206   jresult = (int)result;
66207   return jresult;
66208 }
66209
66210
66211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66212   int jresult ;
66213   int result;
66214
66215   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66216   jresult = (int)result;
66217   return jresult;
66218 }
66219
66220
66221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66222   int jresult ;
66223   int result;
66224
66225   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66226   jresult = (int)result;
66227   return jresult;
66228 }
66229
66230
66231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66232   void * jresult ;
66233   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66234
66235   {
66236     try {
66237       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66238     } catch (std::out_of_range& e) {
66239       {
66240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66241       };
66242     } catch (std::exception& e) {
66243       {
66244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66245       };
66246     } catch (Dali::DaliException e) {
66247       {
66248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66249       };
66250     } catch (...) {
66251       {
66252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66253       };
66254     }
66255   }
66256
66257   jresult = (void *)result;
66258   return jresult;
66259 }
66260
66261
66262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66263   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66264
66265   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66266   {
66267     try {
66268       delete arg1;
66269     } catch (std::out_of_range& e) {
66270       {
66271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66272       };
66273     } catch (std::exception& e) {
66274       {
66275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66276       };
66277     } catch (Dali::DaliException e) {
66278       {
66279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66280       };
66281     } catch (...) {
66282       {
66283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66284       };
66285     }
66286   }
66287
66288 }
66289
66290
66291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66292   void * jresult ;
66293   Dali::Toolkit::FlexContainer *result = 0 ;
66294
66295   {
66296     try {
66297       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66298     } catch (std::out_of_range& e) {
66299       {
66300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66301       };
66302     } catch (std::exception& e) {
66303       {
66304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66305       };
66306     } catch (Dali::DaliException e) {
66307       {
66308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66309       };
66310     } catch (...) {
66311       {
66312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66313       };
66314     }
66315   }
66316
66317   jresult = (void *)result;
66318   return jresult;
66319 }
66320
66321
66322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66323   void * jresult ;
66324   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66325   Dali::Toolkit::FlexContainer *result = 0 ;
66326
66327   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66328   if (!arg1) {
66329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66330     return 0;
66331   }
66332   {
66333     try {
66334       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66335     } catch (std::out_of_range& e) {
66336       {
66337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66338       };
66339     } catch (std::exception& e) {
66340       {
66341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66342       };
66343     } catch (Dali::DaliException e) {
66344       {
66345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66346       };
66347     } catch (...) {
66348       {
66349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66350       };
66351     }
66352   }
66353
66354   jresult = (void *)result;
66355   return jresult;
66356 }
66357
66358
66359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66360   void * jresult ;
66361   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66362   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66363   Dali::Toolkit::FlexContainer *result = 0 ;
66364
66365   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66366   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66367   if (!arg2) {
66368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66369     return 0;
66370   }
66371   {
66372     try {
66373       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66374     } catch (std::out_of_range& e) {
66375       {
66376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66377       };
66378     } catch (std::exception& e) {
66379       {
66380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66381       };
66382     } catch (Dali::DaliException e) {
66383       {
66384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66385       };
66386     } catch (...) {
66387       {
66388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66389       };
66390     }
66391   }
66392
66393   jresult = (void *)result;
66394   return jresult;
66395 }
66396
66397
66398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66399   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66400
66401   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66402   {
66403     try {
66404       delete arg1;
66405     } catch (std::out_of_range& e) {
66406       {
66407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66408       };
66409     } catch (std::exception& e) {
66410       {
66411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66412       };
66413     } catch (Dali::DaliException e) {
66414       {
66415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66416       };
66417     } catch (...) {
66418       {
66419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66420       };
66421     }
66422   }
66423
66424 }
66425
66426
66427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66428   void * jresult ;
66429   Dali::Toolkit::FlexContainer result;
66430
66431   {
66432     try {
66433       result = Dali::Toolkit::FlexContainer::New();
66434     } catch (std::out_of_range& e) {
66435       {
66436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66437       };
66438     } catch (std::exception& e) {
66439       {
66440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66441       };
66442     } catch (Dali::DaliException e) {
66443       {
66444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66445       };
66446     } catch (...) {
66447       {
66448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66449       };
66450     }
66451   }
66452
66453   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66454   return jresult;
66455 }
66456
66457
66458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66459   void * jresult ;
66460   Dali::BaseHandle arg1 ;
66461   Dali::BaseHandle *argp1 ;
66462   Dali::Toolkit::FlexContainer result;
66463
66464   argp1 = (Dali::BaseHandle *)jarg1;
66465   if (!argp1) {
66466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66467     return 0;
66468   }
66469   arg1 = *argp1;
66470   {
66471     try {
66472       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66473     } catch (std::out_of_range& e) {
66474       {
66475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66476       };
66477     } catch (std::exception& e) {
66478       {
66479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66480       };
66481     } catch (Dali::DaliException e) {
66482       {
66483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66484       };
66485     } catch (...) {
66486       {
66487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66488       };
66489     }
66490   }
66491
66492   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66493   return jresult;
66494 }
66495
66496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66497   int jresult ;
66498   int result;
66499
66500   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66501   jresult = (int)result;
66502   return jresult;
66503 }
66504
66505
66506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66507   int jresult ;
66508   int result;
66509
66510   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66511   jresult = (int)result;
66512   return jresult;
66513 }
66514
66515
66516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66517   int jresult ;
66518   int result;
66519
66520   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66521   jresult = (int)result;
66522   return jresult;
66523 }
66524
66525
66526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66527   void * jresult ;
66528   Dali::Toolkit::ImageView::Property *result = 0 ;
66529
66530   {
66531     try {
66532       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66533     } catch (std::out_of_range& e) {
66534       {
66535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66536       };
66537     } catch (std::exception& e) {
66538       {
66539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66540       };
66541     } catch (Dali::DaliException e) {
66542       {
66543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66544       };
66545     } catch (...) {
66546       {
66547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66548       };
66549     }
66550   }
66551
66552   jresult = (void *)result;
66553   return jresult;
66554 }
66555
66556
66557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66558   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66559
66560   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66561   {
66562     try {
66563       delete arg1;
66564     } catch (std::out_of_range& e) {
66565       {
66566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66567       };
66568     } catch (std::exception& e) {
66569       {
66570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66571       };
66572     } catch (Dali::DaliException e) {
66573       {
66574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66575       };
66576     } catch (...) {
66577       {
66578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66579       };
66580     }
66581   }
66582
66583 }
66584
66585
66586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66587   void * jresult ;
66588   Dali::Toolkit::ImageView *result = 0 ;
66589
66590   {
66591     try {
66592       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66593     } catch (std::out_of_range& e) {
66594       {
66595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66596       };
66597     } catch (std::exception& e) {
66598       {
66599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66600       };
66601     } catch (Dali::DaliException e) {
66602       {
66603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66604       };
66605     } catch (...) {
66606       {
66607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66608       };
66609     }
66610   }
66611
66612   jresult = (void *)result;
66613   return jresult;
66614 }
66615
66616
66617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66618   void * jresult ;
66619   Dali::Toolkit::ImageView result;
66620
66621   {
66622     try {
66623       result = Dali::Toolkit::ImageView::New();
66624     } catch (std::out_of_range& e) {
66625       {
66626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66627       };
66628     } catch (std::exception& e) {
66629       {
66630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66631       };
66632     } catch (Dali::DaliException e) {
66633       {
66634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66635       };
66636     } catch (...) {
66637       {
66638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66639       };
66640     }
66641   }
66642
66643   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66644   return jresult;
66645 }
66646
66647
66648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66649   void * jresult ;
66650   std::string *arg1 = 0 ;
66651   Dali::Toolkit::ImageView result;
66652
66653   if (!jarg1) {
66654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66655     return 0;
66656   }
66657   std::string arg1_str(jarg1);
66658   arg1 = &arg1_str;
66659   {
66660     try {
66661       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66662     } catch (std::out_of_range& e) {
66663       {
66664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66665       };
66666     } catch (std::exception& e) {
66667       {
66668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66669       };
66670     } catch (Dali::DaliException e) {
66671       {
66672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66673       };
66674     } catch (...) {
66675       {
66676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66677       };
66678     }
66679   }
66680
66681   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66682
66683   //argout typemap for const std::string&
66684
66685   return jresult;
66686 }
66687
66688
66689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66690   void * jresult ;
66691   std::string *arg1 = 0 ;
66692   Dali::ImageDimensions arg2 ;
66693   Dali::ImageDimensions *argp2 ;
66694   Dali::Toolkit::ImageView result;
66695
66696   if (!jarg1) {
66697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66698     return 0;
66699   }
66700   std::string arg1_str(jarg1);
66701   arg1 = &arg1_str;
66702   argp2 = (Dali::ImageDimensions *)jarg2;
66703   if (!argp2) {
66704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66705     return 0;
66706   }
66707   arg2 = *argp2;
66708   {
66709     try {
66710       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66711     } catch (std::out_of_range& e) {
66712       {
66713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66714       };
66715     } catch (std::exception& e) {
66716       {
66717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66718       };
66719     } catch (Dali::DaliException e) {
66720       {
66721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66722       };
66723     } catch (...) {
66724       {
66725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66726       };
66727     }
66728   }
66729
66730   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66731
66732   //argout typemap for const std::string&
66733
66734   return jresult;
66735 }
66736
66737
66738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66739   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66740
66741   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66742   {
66743     try {
66744       delete arg1;
66745     } catch (std::out_of_range& e) {
66746       {
66747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66748       };
66749     } catch (std::exception& e) {
66750       {
66751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66752       };
66753     } catch (Dali::DaliException e) {
66754       {
66755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66756       };
66757     } catch (...) {
66758       {
66759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66760       };
66761     }
66762   }
66763
66764 }
66765
66766
66767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66768   void * jresult ;
66769   Dali::Toolkit::ImageView *arg1 = 0 ;
66770   Dali::Toolkit::ImageView *result = 0 ;
66771
66772   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66773   if (!arg1) {
66774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66775     return 0;
66776   }
66777   {
66778     try {
66779       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66780     } catch (std::out_of_range& e) {
66781       {
66782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66783       };
66784     } catch (std::exception& e) {
66785       {
66786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66787       };
66788     } catch (Dali::DaliException e) {
66789       {
66790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66791       };
66792     } catch (...) {
66793       {
66794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66795       };
66796     }
66797   }
66798
66799   jresult = (void *)result;
66800   return jresult;
66801 }
66802
66803
66804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66805   void * jresult ;
66806   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66807   Dali::Toolkit::ImageView *arg2 = 0 ;
66808   Dali::Toolkit::ImageView *result = 0 ;
66809
66810   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66811   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66812   if (!arg2) {
66813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66814     return 0;
66815   }
66816   {
66817     try {
66818       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66819     } catch (std::out_of_range& e) {
66820       {
66821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66822       };
66823     } catch (std::exception& e) {
66824       {
66825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66826       };
66827     } catch (Dali::DaliException e) {
66828       {
66829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66830       };
66831     } catch (...) {
66832       {
66833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66834       };
66835     }
66836   }
66837
66838   jresult = (void *)result;
66839   return jresult;
66840 }
66841
66842
66843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66844   void * jresult ;
66845   Dali::BaseHandle arg1 ;
66846   Dali::BaseHandle *argp1 ;
66847   Dali::Toolkit::ImageView result;
66848
66849   argp1 = (Dali::BaseHandle *)jarg1;
66850   if (!argp1) {
66851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66852     return 0;
66853   }
66854   arg1 = *argp1;
66855   {
66856     try {
66857       result = Dali::Toolkit::ImageView::DownCast(arg1);
66858     } catch (std::out_of_range& e) {
66859       {
66860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66861       };
66862     } catch (std::exception& e) {
66863       {
66864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66865       };
66866     } catch (Dali::DaliException e) {
66867       {
66868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66869       };
66870     } catch (...) {
66871       {
66872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66873       };
66874     }
66875   }
66876
66877   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66878   return jresult;
66879 }
66880
66881
66882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66883   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66884   std::string *arg2 = 0 ;
66885
66886   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66887   if (!jarg2) {
66888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66889     return ;
66890   }
66891   std::string arg2_str(jarg2);
66892   arg2 = &arg2_str;
66893   {
66894     try {
66895       (arg1)->SetImage((std::string const &)*arg2);
66896     } catch (std::out_of_range& e) {
66897       {
66898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66899       };
66900     } catch (std::exception& e) {
66901       {
66902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66903       };
66904     } catch (Dali::DaliException e) {
66905       {
66906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66907       };
66908     } catch (...) {
66909       {
66910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66911       };
66912     }
66913   }
66914
66915
66916   //argout typemap for const std::string&
66917
66918 }
66919
66920
66921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66922   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66923   std::string *arg2 = 0 ;
66924   Dali::ImageDimensions arg3 ;
66925   Dali::ImageDimensions *argp3 ;
66926
66927   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66928   if (!jarg2) {
66929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66930     return ;
66931   }
66932   std::string arg2_str(jarg2);
66933   arg2 = &arg2_str;
66934   argp3 = (Dali::ImageDimensions *)jarg3;
66935   if (!argp3) {
66936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66937     return ;
66938   }
66939   arg3 = *argp3;
66940   {
66941     try {
66942       (arg1)->SetImage((std::string const &)*arg2,arg3);
66943     } catch (std::out_of_range& e) {
66944       {
66945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66946       };
66947     } catch (std::exception& e) {
66948       {
66949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66950       };
66951     } catch (Dali::DaliException e) {
66952       {
66953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66954       };
66955     } catch (...) {
66956       {
66957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66958       };
66959     }
66960   }
66961
66962
66963   //argout typemap for const std::string&
66964
66965 }
66966
66967
66968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66969   int jresult ;
66970   int result;
66971
66972   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66973   jresult = (int)result;
66974   return jresult;
66975 }
66976
66977
66978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66979   int jresult ;
66980   int result;
66981
66982   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66983   jresult = (int)result;
66984   return jresult;
66985 }
66986
66987
66988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66989   int jresult ;
66990   int result;
66991
66992   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66993   jresult = (int)result;
66994   return jresult;
66995 }
66996
66997
66998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66999   int jresult ;
67000   int result;
67001
67002   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67003   jresult = (int)result;
67004   return jresult;
67005 }
67006
67007
67008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67009   int jresult ;
67010   int result;
67011
67012   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67013   jresult = (int)result;
67014   return jresult;
67015 }
67016
67017
67018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67019   int jresult ;
67020   int result;
67021
67022   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67023   jresult = (int)result;
67024   return jresult;
67025 }
67026
67027
67028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67029   int jresult ;
67030   int result;
67031
67032   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67033   jresult = (int)result;
67034   return jresult;
67035 }
67036
67037
67038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67039   int jresult ;
67040   int result;
67041
67042   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67043   jresult = (int)result;
67044   return jresult;
67045 }
67046
67047
67048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67049   void * jresult ;
67050   Dali::Toolkit::Model3dView::Property *result = 0 ;
67051
67052   {
67053     try {
67054       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67055     } catch (std::out_of_range& e) {
67056       {
67057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67058       };
67059     } catch (std::exception& e) {
67060       {
67061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67062       };
67063     } catch (Dali::DaliException e) {
67064       {
67065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67066       };
67067     } catch (...) {
67068       {
67069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67070       };
67071     }
67072   }
67073
67074   jresult = (void *)result;
67075   return jresult;
67076 }
67077
67078
67079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67080   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67081
67082   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67083   {
67084     try {
67085       delete arg1;
67086     } catch (std::out_of_range& e) {
67087       {
67088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67089       };
67090     } catch (std::exception& e) {
67091       {
67092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67093       };
67094     } catch (Dali::DaliException e) {
67095       {
67096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67097       };
67098     } catch (...) {
67099       {
67100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67101       };
67102     }
67103   }
67104
67105 }
67106
67107
67108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67109   void * jresult ;
67110   Dali::Toolkit::Model3dView result;
67111
67112   {
67113     try {
67114       result = Dali::Toolkit::Model3dView::New();
67115     } catch (std::out_of_range& e) {
67116       {
67117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67118       };
67119     } catch (std::exception& e) {
67120       {
67121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67122       };
67123     } catch (Dali::DaliException e) {
67124       {
67125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67126       };
67127     } catch (...) {
67128       {
67129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67130       };
67131     }
67132   }
67133
67134   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67135   return jresult;
67136 }
67137
67138
67139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67140   void * jresult ;
67141   std::string *arg1 = 0 ;
67142   std::string *arg2 = 0 ;
67143   std::string *arg3 = 0 ;
67144   Dali::Toolkit::Model3dView result;
67145
67146   if (!jarg1) {
67147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67148     return 0;
67149   }
67150   std::string arg1_str(jarg1);
67151   arg1 = &arg1_str;
67152   if (!jarg2) {
67153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67154     return 0;
67155   }
67156   std::string arg2_str(jarg2);
67157   arg2 = &arg2_str;
67158   if (!jarg3) {
67159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67160     return 0;
67161   }
67162   std::string arg3_str(jarg3);
67163   arg3 = &arg3_str;
67164   {
67165     try {
67166       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67167     } catch (std::out_of_range& e) {
67168       {
67169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67170       };
67171     } catch (std::exception& e) {
67172       {
67173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67174       };
67175     } catch (Dali::DaliException e) {
67176       {
67177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67178       };
67179     } catch (...) {
67180       {
67181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67182       };
67183     }
67184   }
67185
67186   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67187
67188   //argout typemap for const std::string&
67189
67190
67191   //argout typemap for const std::string&
67192
67193
67194   //argout typemap for const std::string&
67195
67196   return jresult;
67197 }
67198
67199
67200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67201   void * jresult ;
67202   Dali::Toolkit::Model3dView *result = 0 ;
67203
67204   {
67205     try {
67206       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67207     } catch (std::out_of_range& e) {
67208       {
67209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67210       };
67211     } catch (std::exception& e) {
67212       {
67213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67214       };
67215     } catch (Dali::DaliException e) {
67216       {
67217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67218       };
67219     } catch (...) {
67220       {
67221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67222       };
67223     }
67224   }
67225
67226   jresult = (void *)result;
67227   return jresult;
67228 }
67229
67230
67231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67232   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67233
67234   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67235   {
67236     try {
67237       delete arg1;
67238     } catch (std::out_of_range& e) {
67239       {
67240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67241       };
67242     } catch (std::exception& e) {
67243       {
67244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67245       };
67246     } catch (Dali::DaliException e) {
67247       {
67248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67249       };
67250     } catch (...) {
67251       {
67252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67253       };
67254     }
67255   }
67256
67257 }
67258
67259
67260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67261   void * jresult ;
67262   Dali::Toolkit::Model3dView *arg1 = 0 ;
67263   Dali::Toolkit::Model3dView *result = 0 ;
67264
67265   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67266   if (!arg1) {
67267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67268     return 0;
67269   }
67270   {
67271     try {
67272       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67273     } catch (std::out_of_range& e) {
67274       {
67275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67276       };
67277     } catch (std::exception& e) {
67278       {
67279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67280       };
67281     } catch (Dali::DaliException e) {
67282       {
67283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67284       };
67285     } catch (...) {
67286       {
67287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67288       };
67289     }
67290   }
67291
67292   jresult = (void *)result;
67293   return jresult;
67294 }
67295
67296
67297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67298   void * jresult ;
67299   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67300   Dali::Toolkit::Model3dView *arg2 = 0 ;
67301   Dali::Toolkit::Model3dView *result = 0 ;
67302
67303   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67304   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67305   if (!arg2) {
67306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67307     return 0;
67308   }
67309   {
67310     try {
67311       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67312     } catch (std::out_of_range& e) {
67313       {
67314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67315       };
67316     } catch (std::exception& e) {
67317       {
67318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67319       };
67320     } catch (Dali::DaliException e) {
67321       {
67322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67323       };
67324     } catch (...) {
67325       {
67326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67327       };
67328     }
67329   }
67330
67331   jresult = (void *)result;
67332   return jresult;
67333 }
67334
67335
67336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67337   void * jresult ;
67338   Dali::BaseHandle arg1 ;
67339   Dali::BaseHandle *argp1 ;
67340   Dali::Toolkit::Model3dView result;
67341
67342   argp1 = (Dali::BaseHandle *)jarg1;
67343   if (!argp1) {
67344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67345     return 0;
67346   }
67347   arg1 = *argp1;
67348   {
67349     try {
67350       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67351     } catch (std::out_of_range& e) {
67352       {
67353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67354       };
67355     } catch (std::exception& e) {
67356       {
67357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67358       };
67359     } catch (Dali::DaliException e) {
67360       {
67361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67362       };
67363     } catch (...) {
67364       {
67365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67366       };
67367     }
67368   }
67369
67370   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67371   return jresult;
67372 }
67373
67374
67375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67376   int jresult ;
67377   int result;
67378
67379   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67380   jresult = (int)result;
67381   return jresult;
67382 }
67383
67384
67385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67386   int jresult ;
67387   int result;
67388
67389   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67390   jresult = (int)result;
67391   return jresult;
67392 }
67393
67394
67395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67396   int jresult ;
67397   int result;
67398
67399   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67400   jresult = (int)result;
67401   return jresult;
67402 }
67403
67404
67405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67406   int jresult ;
67407   int result;
67408
67409   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67410   jresult = (int)result;
67411   return jresult;
67412 }
67413
67414
67415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67416   int jresult ;
67417   int result;
67418
67419   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67420   jresult = (int)result;
67421   return jresult;
67422 }
67423
67424
67425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67426   int jresult ;
67427   int result;
67428
67429   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67430   jresult = (int)result;
67431   return jresult;
67432 }
67433
67434
67435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67436   int jresult ;
67437   int result;
67438
67439   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67440   jresult = (int)result;
67441   return jresult;
67442 }
67443
67444
67445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67446   int jresult ;
67447   int result;
67448
67449   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67450   jresult = (int)result;
67451   return jresult;
67452 }
67453
67454
67455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67456   int jresult ;
67457   int result;
67458
67459   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67460   jresult = (int)result;
67461   return jresult;
67462 }
67463
67464
67465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67466   void * jresult ;
67467   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67468
67469   {
67470     try {
67471       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67472     } catch (std::out_of_range& e) {
67473       {
67474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67475       };
67476     } catch (std::exception& e) {
67477       {
67478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67479       };
67480     } catch (Dali::DaliException e) {
67481       {
67482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67483       };
67484     } catch (...) {
67485       {
67486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67487       };
67488     }
67489   }
67490
67491   jresult = (void *)result;
67492   return jresult;
67493 }
67494
67495
67496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67497   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67498
67499   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67500   {
67501     try {
67502       delete arg1;
67503     } catch (std::out_of_range& e) {
67504       {
67505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67506       };
67507     } catch (std::exception& e) {
67508       {
67509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67510       };
67511     } catch (Dali::DaliException e) {
67512       {
67513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67514       };
67515     } catch (...) {
67516       {
67517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67518       };
67519     }
67520   }
67521
67522 }
67523
67524
67525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67526   void * jresult ;
67527   Dali::Toolkit::ScrollBar *result = 0 ;
67528
67529   {
67530     try {
67531       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67532     } catch (std::out_of_range& e) {
67533       {
67534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67535       };
67536     } catch (std::exception& e) {
67537       {
67538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67539       };
67540     } catch (Dali::DaliException e) {
67541       {
67542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67543       };
67544     } catch (...) {
67545       {
67546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67547       };
67548     }
67549   }
67550
67551   jresult = (void *)result;
67552   return jresult;
67553 }
67554
67555
67556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67557   void * jresult ;
67558   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67559   Dali::Toolkit::ScrollBar *result = 0 ;
67560
67561   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67562   if (!arg1) {
67563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67564     return 0;
67565   }
67566   {
67567     try {
67568       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67569     } catch (std::out_of_range& e) {
67570       {
67571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67572       };
67573     } catch (std::exception& e) {
67574       {
67575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67576       };
67577     } catch (Dali::DaliException e) {
67578       {
67579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67580       };
67581     } catch (...) {
67582       {
67583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67584       };
67585     }
67586   }
67587
67588   jresult = (void *)result;
67589   return jresult;
67590 }
67591
67592
67593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67594   void * jresult ;
67595   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67596   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67597   Dali::Toolkit::ScrollBar *result = 0 ;
67598
67599   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67600   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67601   if (!arg2) {
67602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67603     return 0;
67604   }
67605   {
67606     try {
67607       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67608     } catch (std::out_of_range& e) {
67609       {
67610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67611       };
67612     } catch (std::exception& e) {
67613       {
67614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67615       };
67616     } catch (Dali::DaliException e) {
67617       {
67618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67619       };
67620     } catch (...) {
67621       {
67622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67623       };
67624     }
67625   }
67626
67627   jresult = (void *)result;
67628   return jresult;
67629 }
67630
67631
67632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67633   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67634
67635   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67636   {
67637     try {
67638       delete arg1;
67639     } catch (std::out_of_range& e) {
67640       {
67641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67642       };
67643     } catch (std::exception& e) {
67644       {
67645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67646       };
67647     } catch (Dali::DaliException e) {
67648       {
67649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67650       };
67651     } catch (...) {
67652       {
67653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67654       };
67655     }
67656   }
67657
67658 }
67659
67660
67661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67662   void * jresult ;
67663   Dali::Toolkit::ScrollBar::Direction arg1 ;
67664   Dali::Toolkit::ScrollBar result;
67665
67666   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67667   {
67668     try {
67669       result = Dali::Toolkit::ScrollBar::New(arg1);
67670     } catch (std::out_of_range& e) {
67671       {
67672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67673       };
67674     } catch (std::exception& e) {
67675       {
67676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67677       };
67678     } catch (Dali::DaliException e) {
67679       {
67680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67681       };
67682     } catch (...) {
67683       {
67684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67685       };
67686     }
67687   }
67688
67689   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67690   return jresult;
67691 }
67692
67693
67694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67695   void * jresult ;
67696   Dali::Toolkit::ScrollBar result;
67697
67698   {
67699     try {
67700       result = Dali::Toolkit::ScrollBar::New();
67701     } catch (std::out_of_range& e) {
67702       {
67703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67704       };
67705     } catch (std::exception& e) {
67706       {
67707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67708       };
67709     } catch (Dali::DaliException e) {
67710       {
67711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67712       };
67713     } catch (...) {
67714       {
67715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67716       };
67717     }
67718   }
67719
67720   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67721   return jresult;
67722 }
67723
67724
67725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67726   void * jresult ;
67727   Dali::BaseHandle arg1 ;
67728   Dali::BaseHandle *argp1 ;
67729   Dali::Toolkit::ScrollBar result;
67730
67731   argp1 = (Dali::BaseHandle *)jarg1;
67732   if (!argp1) {
67733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67734     return 0;
67735   }
67736   arg1 = *argp1;
67737   {
67738     try {
67739       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67740     } catch (std::out_of_range& e) {
67741       {
67742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67743       };
67744     } catch (std::exception& e) {
67745       {
67746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67747       };
67748     } catch (Dali::DaliException e) {
67749       {
67750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67751       };
67752     } catch (...) {
67753       {
67754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67755       };
67756     }
67757   }
67758
67759   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67760   return jresult;
67761 }
67762
67763
67764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67765   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67766   Dali::Handle arg2 ;
67767   Dali::Property::Index arg3 ;
67768   Dali::Property::Index arg4 ;
67769   Dali::Property::Index arg5 ;
67770   Dali::Property::Index arg6 ;
67771   Dali::Handle *argp2 ;
67772
67773   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67774   argp2 = (Dali::Handle *)jarg2;
67775   if (!argp2) {
67776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67777     return ;
67778   }
67779   arg2 = *argp2;
67780   arg3 = (Dali::Property::Index)jarg3;
67781   arg4 = (Dali::Property::Index)jarg4;
67782   arg5 = (Dali::Property::Index)jarg5;
67783   arg6 = (Dali::Property::Index)jarg6;
67784   {
67785     try {
67786       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67787     } catch (std::out_of_range& e) {
67788       {
67789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67790       };
67791     } catch (std::exception& e) {
67792       {
67793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67794       };
67795     } catch (Dali::DaliException e) {
67796       {
67797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67798       };
67799     } catch (...) {
67800       {
67801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67802       };
67803     }
67804   }
67805
67806 }
67807
67808
67809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67810   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67811   Dali::Actor arg2 ;
67812   Dali::Actor *argp2 ;
67813
67814   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67815   argp2 = (Dali::Actor *)jarg2;
67816   if (!argp2) {
67817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67818     return ;
67819   }
67820   arg2 = *argp2;
67821   {
67822     try {
67823       (arg1)->SetScrollIndicator(arg2);
67824     } catch (std::out_of_range& e) {
67825       {
67826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67827       };
67828     } catch (std::exception& e) {
67829       {
67830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67831       };
67832     } catch (Dali::DaliException e) {
67833       {
67834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67835       };
67836     } catch (...) {
67837       {
67838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67839       };
67840     }
67841   }
67842
67843 }
67844
67845
67846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67847   void * jresult ;
67848   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67849   Dali::Actor result;
67850
67851   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67852   {
67853     try {
67854       result = (arg1)->GetScrollIndicator();
67855     } catch (std::out_of_range& e) {
67856       {
67857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67858       };
67859     } catch (std::exception& e) {
67860       {
67861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67862       };
67863     } catch (Dali::DaliException e) {
67864       {
67865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67866       };
67867     } catch (...) {
67868       {
67869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67870       };
67871     }
67872   }
67873
67874   jresult = new Dali::Actor((const Dali::Actor &)result);
67875   return jresult;
67876 }
67877
67878
67879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67880   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67881   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67882
67883   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67884   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67885   if (!arg2) {
67886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67887     return ;
67888   }
67889   {
67890     try {
67891       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67892     } catch (std::out_of_range& e) {
67893       {
67894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67895       };
67896     } catch (std::exception& e) {
67897       {
67898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67899       };
67900     } catch (Dali::DaliException e) {
67901       {
67902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67903       };
67904     } catch (...) {
67905       {
67906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67907       };
67908     }
67909   }
67910
67911 }
67912
67913
67914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67915   void * jresult ;
67916   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67917
67918   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67919   {
67920     try {
67921       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()));
67922     } catch (std::out_of_range& e) {
67923       {
67924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67925       };
67926     } catch (std::exception& e) {
67927       {
67928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67929       };
67930     } catch (...) {
67931       {
67932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67933       };
67934     }
67935   }
67936   return jresult;
67937 }
67938
67939
67940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67941   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67942   Dali::Toolkit::ScrollBar::Direction arg2 ;
67943
67944   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67945   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67946   {
67947     try {
67948       (arg1)->SetScrollDirection(arg2);
67949     } catch (std::out_of_range& e) {
67950       {
67951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67952       };
67953     } catch (std::exception& e) {
67954       {
67955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67956       };
67957     } catch (Dali::DaliException e) {
67958       {
67959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67960       };
67961     } catch (...) {
67962       {
67963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67964       };
67965     }
67966   }
67967
67968 }
67969
67970
67971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67972   int jresult ;
67973   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67974   Dali::Toolkit::ScrollBar::Direction result;
67975
67976   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67977   {
67978     try {
67979       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67980     } catch (std::out_of_range& e) {
67981       {
67982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67983       };
67984     } catch (std::exception& e) {
67985       {
67986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67987       };
67988     } catch (Dali::DaliException e) {
67989       {
67990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67991       };
67992     } catch (...) {
67993       {
67994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67995       };
67996     }
67997   }
67998
67999   jresult = (int)result;
68000   return jresult;
68001 }
68002
68003
68004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68005   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68006   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68007
68008   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68009   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68010   {
68011     try {
68012       (arg1)->SetIndicatorHeightPolicy(arg2);
68013     } catch (std::out_of_range& e) {
68014       {
68015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68016       };
68017     } catch (std::exception& e) {
68018       {
68019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68020       };
68021     } catch (Dali::DaliException e) {
68022       {
68023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68024       };
68025     } catch (...) {
68026       {
68027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68028       };
68029     }
68030   }
68031
68032 }
68033
68034
68035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68036   int jresult ;
68037   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68038   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68039
68040   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68041   {
68042     try {
68043       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68044     } catch (std::out_of_range& e) {
68045       {
68046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68047       };
68048     } catch (std::exception& e) {
68049       {
68050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68051       };
68052     } catch (Dali::DaliException e) {
68053       {
68054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68055       };
68056     } catch (...) {
68057       {
68058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68059       };
68060     }
68061   }
68062
68063   jresult = (int)result;
68064   return jresult;
68065 }
68066
68067
68068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68069   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68070   float arg2 ;
68071
68072   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68073   arg2 = (float)jarg2;
68074   {
68075     try {
68076       (arg1)->SetIndicatorFixedHeight(arg2);
68077     } catch (std::out_of_range& e) {
68078       {
68079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68080       };
68081     } catch (std::exception& e) {
68082       {
68083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68084       };
68085     } catch (Dali::DaliException e) {
68086       {
68087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68088       };
68089     } catch (...) {
68090       {
68091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68092       };
68093     }
68094   }
68095
68096 }
68097
68098
68099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68100   float jresult ;
68101   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68102   float result;
68103
68104   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68105   {
68106     try {
68107       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68108     } catch (std::out_of_range& e) {
68109       {
68110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68111       };
68112     } catch (std::exception& e) {
68113       {
68114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68115       };
68116     } catch (Dali::DaliException e) {
68117       {
68118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68119       };
68120     } catch (...) {
68121       {
68122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68123       };
68124     }
68125   }
68126
68127   jresult = result;
68128   return jresult;
68129 }
68130
68131
68132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68133   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68134   float arg2 ;
68135
68136   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68137   arg2 = (float)jarg2;
68138   {
68139     try {
68140       (arg1)->SetIndicatorShowDuration(arg2);
68141     } catch (std::out_of_range& e) {
68142       {
68143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68144       };
68145     } catch (std::exception& e) {
68146       {
68147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68148       };
68149     } catch (Dali::DaliException e) {
68150       {
68151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68152       };
68153     } catch (...) {
68154       {
68155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68156       };
68157     }
68158   }
68159
68160 }
68161
68162
68163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68164   float jresult ;
68165   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68166   float result;
68167
68168   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68169   {
68170     try {
68171       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68172     } catch (std::out_of_range& e) {
68173       {
68174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68175       };
68176     } catch (std::exception& e) {
68177       {
68178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68179       };
68180     } catch (Dali::DaliException e) {
68181       {
68182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68183       };
68184     } catch (...) {
68185       {
68186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68187       };
68188     }
68189   }
68190
68191   jresult = result;
68192   return jresult;
68193 }
68194
68195
68196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68197   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68198   float arg2 ;
68199
68200   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68201   arg2 = (float)jarg2;
68202   {
68203     try {
68204       (arg1)->SetIndicatorHideDuration(arg2);
68205     } catch (std::out_of_range& e) {
68206       {
68207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68208       };
68209     } catch (std::exception& e) {
68210       {
68211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68212       };
68213     } catch (Dali::DaliException e) {
68214       {
68215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68216       };
68217     } catch (...) {
68218       {
68219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68220       };
68221     }
68222   }
68223
68224 }
68225
68226
68227 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68228   float jresult ;
68229   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68230   float result;
68231
68232   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68233   {
68234     try {
68235       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68236     } catch (std::out_of_range& e) {
68237       {
68238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68239       };
68240     } catch (std::exception& e) {
68241       {
68242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68243       };
68244     } catch (Dali::DaliException e) {
68245       {
68246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68247       };
68248     } catch (...) {
68249       {
68250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68251       };
68252     }
68253   }
68254
68255   jresult = result;
68256   return jresult;
68257 }
68258
68259
68260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68261   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68262
68263   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68264   {
68265     try {
68266       (arg1)->ShowIndicator();
68267     } catch (std::out_of_range& e) {
68268       {
68269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68270       };
68271     } catch (std::exception& e) {
68272       {
68273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68274       };
68275     } catch (Dali::DaliException e) {
68276       {
68277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68278       };
68279     } catch (...) {
68280       {
68281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68282       };
68283     }
68284   }
68285
68286 }
68287
68288
68289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68290   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68291
68292   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68293   {
68294     try {
68295       (arg1)->HideIndicator();
68296     } catch (std::out_of_range& e) {
68297       {
68298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68299       };
68300     } catch (std::exception& e) {
68301       {
68302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68303       };
68304     } catch (Dali::DaliException e) {
68305       {
68306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68307       };
68308     } catch (...) {
68309       {
68310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68311       };
68312     }
68313   }
68314
68315 }
68316
68317
68318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68319   void * jresult ;
68320   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68321   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68322
68323   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68324   {
68325     try {
68326       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68327     } catch (std::out_of_range& e) {
68328       {
68329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68330       };
68331     } catch (std::exception& e) {
68332       {
68333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68334       };
68335     } catch (Dali::DaliException e) {
68336       {
68337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68338       };
68339     } catch (...) {
68340       {
68341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68342       };
68343     }
68344   }
68345
68346   jresult = (void *)result;
68347   return jresult;
68348 }
68349
68350
68351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68352   void * jresult ;
68353   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68354   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68355
68356   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68357   {
68358     try {
68359       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68360     } catch (std::out_of_range& e) {
68361       {
68362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68363       };
68364     } catch (std::exception& e) {
68365       {
68366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68367       };
68368     } catch (Dali::DaliException e) {
68369       {
68370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68371       };
68372     } catch (...) {
68373       {
68374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68375       };
68376     }
68377   }
68378
68379   jresult = (void *)result;
68380   return jresult;
68381 }
68382
68383
68384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68385   int jresult ;
68386   int result;
68387
68388   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68389   jresult = (int)result;
68390   return jresult;
68391 }
68392
68393
68394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68395   int jresult ;
68396   int result;
68397
68398   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68399   jresult = (int)result;
68400   return jresult;
68401 }
68402
68403
68404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68405   int jresult ;
68406   int result;
68407
68408   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68409   jresult = (int)result;
68410   return jresult;
68411 }
68412
68413
68414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68415   int jresult ;
68416   int result;
68417
68418   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68419   jresult = (int)result;
68420   return jresult;
68421 }
68422
68423
68424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68425   int jresult ;
68426   int result;
68427
68428   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68429   jresult = (int)result;
68430   return jresult;
68431 }
68432
68433
68434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68435   int jresult ;
68436   int result;
68437
68438   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68439   jresult = (int)result;
68440   return jresult;
68441 }
68442
68443
68444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68445   int jresult ;
68446   int result;
68447
68448   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68449   jresult = (int)result;
68450   return jresult;
68451 }
68452
68453
68454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68455   int jresult ;
68456   int result;
68457
68458   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68459   jresult = (int)result;
68460   return jresult;
68461 }
68462
68463
68464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68465   int jresult ;
68466   int result;
68467
68468   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68469   jresult = (int)result;
68470   return jresult;
68471 }
68472
68473
68474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68475   int jresult ;
68476   int result;
68477
68478   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68479   jresult = (int)result;
68480   return jresult;
68481 }
68482
68483
68484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68485   int jresult ;
68486   int result;
68487
68488   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68489   jresult = (int)result;
68490   return jresult;
68491 }
68492
68493
68494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68495   int jresult ;
68496   int result;
68497
68498   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68499   jresult = (int)result;
68500   return jresult;
68501 }
68502
68503
68504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68505   int jresult ;
68506   int result;
68507
68508   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68509   jresult = (int)result;
68510   return jresult;
68511 }
68512
68513
68514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68515   int jresult ;
68516   int result;
68517
68518   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68519   jresult = (int)result;
68520   return jresult;
68521 }
68522
68523
68524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68525   void * jresult ;
68526   Dali::Toolkit::Scrollable::Property *result = 0 ;
68527
68528   {
68529     try {
68530       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68531     } catch (std::out_of_range& e) {
68532       {
68533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68534       };
68535     } catch (std::exception& e) {
68536       {
68537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68538       };
68539     } catch (Dali::DaliException e) {
68540       {
68541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68542       };
68543     } catch (...) {
68544       {
68545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68546       };
68547     }
68548   }
68549
68550   jresult = (void *)result;
68551   return jresult;
68552 }
68553
68554
68555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68556   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68557
68558   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68559   {
68560     try {
68561       delete arg1;
68562     } catch (std::out_of_range& e) {
68563       {
68564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68565       };
68566     } catch (std::exception& e) {
68567       {
68568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68569       };
68570     } catch (Dali::DaliException e) {
68571       {
68572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68573       };
68574     } catch (...) {
68575       {
68576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68577       };
68578     }
68579   }
68580
68581 }
68582
68583
68584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68585   void * jresult ;
68586   Dali::Toolkit::Scrollable *result = 0 ;
68587
68588   {
68589     try {
68590       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68591     } catch (std::out_of_range& e) {
68592       {
68593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68594       };
68595     } catch (std::exception& e) {
68596       {
68597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68598       };
68599     } catch (Dali::DaliException e) {
68600       {
68601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68602       };
68603     } catch (...) {
68604       {
68605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68606       };
68607     }
68608   }
68609
68610   jresult = (void *)result;
68611   return jresult;
68612 }
68613
68614
68615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68616   void * jresult ;
68617   Dali::Toolkit::Scrollable *arg1 = 0 ;
68618   Dali::Toolkit::Scrollable *result = 0 ;
68619
68620   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68621   if (!arg1) {
68622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68623     return 0;
68624   }
68625   {
68626     try {
68627       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68628     } catch (std::out_of_range& e) {
68629       {
68630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68631       };
68632     } catch (std::exception& e) {
68633       {
68634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68635       };
68636     } catch (Dali::DaliException e) {
68637       {
68638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68639       };
68640     } catch (...) {
68641       {
68642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68643       };
68644     }
68645   }
68646
68647   jresult = (void *)result;
68648   return jresult;
68649 }
68650
68651
68652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68653   void * jresult ;
68654   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68655   Dali::Toolkit::Scrollable *arg2 = 0 ;
68656   Dali::Toolkit::Scrollable *result = 0 ;
68657
68658   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68659   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68660   if (!arg2) {
68661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68662     return 0;
68663   }
68664   {
68665     try {
68666       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68667     } catch (std::out_of_range& e) {
68668       {
68669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68670       };
68671     } catch (std::exception& e) {
68672       {
68673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68674       };
68675     } catch (Dali::DaliException e) {
68676       {
68677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68678       };
68679     } catch (...) {
68680       {
68681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68682       };
68683     }
68684   }
68685
68686   jresult = (void *)result;
68687   return jresult;
68688 }
68689
68690
68691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68692   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68693
68694   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68695   {
68696     try {
68697       delete arg1;
68698     } catch (std::out_of_range& e) {
68699       {
68700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68701       };
68702     } catch (std::exception& e) {
68703       {
68704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68705       };
68706     } catch (Dali::DaliException e) {
68707       {
68708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68709       };
68710     } catch (...) {
68711       {
68712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68713       };
68714     }
68715   }
68716
68717 }
68718
68719
68720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68721   void * jresult ;
68722   Dali::BaseHandle arg1 ;
68723   Dali::BaseHandle *argp1 ;
68724   Dali::Toolkit::Scrollable result;
68725
68726   argp1 = (Dali::BaseHandle *)jarg1;
68727   if (!argp1) {
68728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68729     return 0;
68730   }
68731   arg1 = *argp1;
68732   {
68733     try {
68734       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68735     } catch (std::out_of_range& e) {
68736       {
68737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68738       };
68739     } catch (std::exception& e) {
68740       {
68741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68742       };
68743     } catch (Dali::DaliException e) {
68744       {
68745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68746       };
68747     } catch (...) {
68748       {
68749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68750       };
68751     }
68752   }
68753
68754   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68755   return jresult;
68756 }
68757
68758
68759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68760   unsigned int jresult ;
68761   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68762   bool result;
68763
68764   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68765   {
68766     try {
68767       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68768     } catch (std::out_of_range& e) {
68769       {
68770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68771       };
68772     } catch (std::exception& e) {
68773       {
68774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68775       };
68776     } catch (Dali::DaliException e) {
68777       {
68778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68779       };
68780     } catch (...) {
68781       {
68782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68783       };
68784     }
68785   }
68786
68787   jresult = result;
68788   return jresult;
68789 }
68790
68791
68792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68793   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68794   bool arg2 ;
68795
68796   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68797   arg2 = jarg2 ? true : false;
68798   {
68799     try {
68800       (arg1)->SetOvershootEnabled(arg2);
68801     } catch (std::out_of_range& e) {
68802       {
68803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68804       };
68805     } catch (std::exception& e) {
68806       {
68807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68808       };
68809     } catch (Dali::DaliException e) {
68810       {
68811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68812       };
68813     } catch (...) {
68814       {
68815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68816       };
68817     }
68818   }
68819
68820 }
68821
68822
68823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68824   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68825   Dali::Vector4 *arg2 = 0 ;
68826
68827   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68828   arg2 = (Dali::Vector4 *)jarg2;
68829   if (!arg2) {
68830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68831     return ;
68832   }
68833   {
68834     try {
68835       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68836     } catch (std::out_of_range& e) {
68837       {
68838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68839       };
68840     } catch (std::exception& e) {
68841       {
68842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68843       };
68844     } catch (Dali::DaliException e) {
68845       {
68846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68847       };
68848     } catch (...) {
68849       {
68850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68851       };
68852     }
68853   }
68854
68855 }
68856
68857
68858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68859   void * jresult ;
68860   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68861   Dali::Vector4 result;
68862
68863   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68864   {
68865     try {
68866       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68867     } catch (std::out_of_range& e) {
68868       {
68869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68870       };
68871     } catch (std::exception& e) {
68872       {
68873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68874       };
68875     } catch (Dali::DaliException e) {
68876       {
68877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68878       };
68879     } catch (...) {
68880       {
68881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68882       };
68883     }
68884   }
68885
68886   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68887   return jresult;
68888 }
68889
68890
68891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68892   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68893   float arg2 ;
68894
68895   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68896   arg2 = (float)jarg2;
68897   {
68898     try {
68899       (arg1)->SetOvershootAnimationSpeed(arg2);
68900     } catch (std::out_of_range& e) {
68901       {
68902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68903       };
68904     } catch (std::exception& e) {
68905       {
68906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68907       };
68908     } catch (Dali::DaliException e) {
68909       {
68910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68911       };
68912     } catch (...) {
68913       {
68914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68915       };
68916     }
68917   }
68918
68919 }
68920
68921
68922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68923   float jresult ;
68924   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68925   float result;
68926
68927   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68928   {
68929     try {
68930       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68931     } catch (std::out_of_range& e) {
68932       {
68933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68934       };
68935     } catch (std::exception& e) {
68936       {
68937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68938       };
68939     } catch (Dali::DaliException e) {
68940       {
68941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68942       };
68943     } catch (...) {
68944       {
68945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68946       };
68947     }
68948   }
68949
68950   jresult = result;
68951   return jresult;
68952 }
68953
68954
68955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68956   void * jresult ;
68957   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68958   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68959
68960   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68961   {
68962     try {
68963       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68964     } catch (std::out_of_range& e) {
68965       {
68966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68967       };
68968     } catch (std::exception& e) {
68969       {
68970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68971       };
68972     } catch (Dali::DaliException e) {
68973       {
68974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68975       };
68976     } catch (...) {
68977       {
68978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68979       };
68980     }
68981   }
68982
68983   jresult = (void *)result;
68984   return jresult;
68985 }
68986
68987
68988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68989   void * jresult ;
68990   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68991   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68992
68993   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68994   {
68995     try {
68996       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68997     } catch (std::out_of_range& e) {
68998       {
68999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69000       };
69001     } catch (std::exception& e) {
69002       {
69003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69004       };
69005     } catch (Dali::DaliException e) {
69006       {
69007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69008       };
69009     } catch (...) {
69010       {
69011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69012       };
69013     }
69014   }
69015
69016   jresult = (void *)result;
69017   return jresult;
69018 }
69019
69020
69021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69022   void * jresult ;
69023   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69024   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69025
69026   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69027   {
69028     try {
69029       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69030     } catch (std::out_of_range& e) {
69031       {
69032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69033       };
69034     } catch (std::exception& e) {
69035       {
69036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69037       };
69038     } catch (Dali::DaliException e) {
69039       {
69040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69041       };
69042     } catch (...) {
69043       {
69044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69045       };
69046     }
69047   }
69048
69049   jresult = (void *)result;
69050   return jresult;
69051 }
69052
69053
69054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69055   unsigned int jresult ;
69056   Dali::Toolkit::ControlOrientation::Type arg1 ;
69057   bool result;
69058
69059   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69060   {
69061     try {
69062       result = (bool)Dali::Toolkit::IsVertical(arg1);
69063     } catch (std::out_of_range& e) {
69064       {
69065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69066       };
69067     } catch (std::exception& e) {
69068       {
69069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69070       };
69071     } catch (Dali::DaliException e) {
69072       {
69073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69074       };
69075     } catch (...) {
69076       {
69077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69078       };
69079     }
69080   }
69081
69082   jresult = result;
69083   return jresult;
69084 }
69085
69086
69087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69088   unsigned int jresult ;
69089   Dali::Toolkit::ControlOrientation::Type arg1 ;
69090   bool result;
69091
69092   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69093   {
69094     try {
69095       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69096     } catch (std::out_of_range& e) {
69097       {
69098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69099       };
69100     } catch (std::exception& e) {
69101       {
69102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69103       };
69104     } catch (Dali::DaliException e) {
69105       {
69106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69107       };
69108     } catch (...) {
69109       {
69110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69111       };
69112     }
69113   }
69114
69115   jresult = result;
69116   return jresult;
69117 }
69118
69119
69120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69121   void * jresult ;
69122   unsigned int arg1 ;
69123   unsigned int arg2 ;
69124   Dali::Toolkit::ItemRange *result = 0 ;
69125
69126   arg1 = (unsigned int)jarg1;
69127   arg2 = (unsigned int)jarg2;
69128   {
69129     try {
69130       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69131     } catch (std::out_of_range& e) {
69132       {
69133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69134       };
69135     } catch (std::exception& e) {
69136       {
69137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69138       };
69139     } catch (Dali::DaliException e) {
69140       {
69141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69142       };
69143     } catch (...) {
69144       {
69145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69146       };
69147     }
69148   }
69149
69150   jresult = (void *)result;
69151   return jresult;
69152 }
69153
69154
69155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69156   void * jresult ;
69157   Dali::Toolkit::ItemRange *arg1 = 0 ;
69158   Dali::Toolkit::ItemRange *result = 0 ;
69159
69160   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69161   if (!arg1) {
69162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69163     return 0;
69164   }
69165   {
69166     try {
69167       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69168     } catch (std::out_of_range& e) {
69169       {
69170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69171       };
69172     } catch (std::exception& e) {
69173       {
69174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69175       };
69176     } catch (Dali::DaliException e) {
69177       {
69178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69179       };
69180     } catch (...) {
69181       {
69182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69183       };
69184     }
69185   }
69186
69187   jresult = (void *)result;
69188   return jresult;
69189 }
69190
69191
69192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69193   void * jresult ;
69194   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69195   Dali::Toolkit::ItemRange *arg2 = 0 ;
69196   Dali::Toolkit::ItemRange *result = 0 ;
69197
69198   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69199   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69200   if (!arg2) {
69201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69202     return 0;
69203   }
69204   {
69205     try {
69206       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69207     } catch (std::out_of_range& e) {
69208       {
69209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (std::exception& e) {
69212       {
69213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69214       };
69215     } catch (Dali::DaliException e) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69218       };
69219     } catch (...) {
69220       {
69221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69222       };
69223     }
69224   }
69225
69226   jresult = (void *)result;
69227   return jresult;
69228 }
69229
69230
69231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69232   unsigned int jresult ;
69233   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69234   unsigned int arg2 ;
69235   bool result;
69236
69237   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69238   arg2 = (unsigned int)jarg2;
69239   {
69240     try {
69241       result = (bool)(arg1)->Within(arg2);
69242     } catch (std::out_of_range& e) {
69243       {
69244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69245       };
69246     } catch (std::exception& e) {
69247       {
69248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69249       };
69250     } catch (Dali::DaliException e) {
69251       {
69252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69253       };
69254     } catch (...) {
69255       {
69256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69257       };
69258     }
69259   }
69260
69261   jresult = result;
69262   return jresult;
69263 }
69264
69265
69266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69267   void * jresult ;
69268   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69269   Dali::Toolkit::ItemRange *arg2 = 0 ;
69270   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69271
69272   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69273   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69274   if (!arg2) {
69275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69276     return 0;
69277   }
69278   {
69279     try {
69280       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69281     } catch (std::out_of_range& e) {
69282       {
69283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69284       };
69285     } catch (std::exception& e) {
69286       {
69287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69288       };
69289     } catch (Dali::DaliException e) {
69290       {
69291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69292       };
69293     } catch (...) {
69294       {
69295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69296       };
69297     }
69298   }
69299
69300   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69301   return jresult;
69302 }
69303
69304
69305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69306   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69307   unsigned int arg2 ;
69308
69309   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69310   arg2 = (unsigned int)jarg2;
69311   if (arg1) (arg1)->begin = arg2;
69312 }
69313
69314
69315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69316   unsigned int jresult ;
69317   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69318   unsigned int result;
69319
69320   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69321   result = (unsigned int) ((arg1)->begin);
69322   jresult = result;
69323   return jresult;
69324 }
69325
69326
69327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69328   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69329   unsigned int arg2 ;
69330
69331   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69332   arg2 = (unsigned int)jarg2;
69333   if (arg1) (arg1)->end = arg2;
69334 }
69335
69336
69337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69338   unsigned int jresult ;
69339   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69340   unsigned int result;
69341
69342   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69343   result = (unsigned int) ((arg1)->end);
69344   jresult = result;
69345   return jresult;
69346 }
69347
69348
69349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69350   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69351
69352   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69353   {
69354     try {
69355       delete arg1;
69356     } catch (std::out_of_range& e) {
69357       {
69358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69359       };
69360     } catch (std::exception& e) {
69361       {
69362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69363       };
69364     } catch (Dali::DaliException e) {
69365       {
69366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69367       };
69368     } catch (...) {
69369       {
69370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69371       };
69372     }
69373   }
69374
69375 }
69376
69377
69378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69379   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69380
69381   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69382   {
69383     try {
69384       delete arg1;
69385     } catch (std::out_of_range& e) {
69386       {
69387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69388       };
69389     } catch (std::exception& e) {
69390       {
69391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69392       };
69393     } catch (Dali::DaliException e) {
69394       {
69395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69396       };
69397     } catch (...) {
69398       {
69399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69400       };
69401     }
69402   }
69403
69404 }
69405
69406
69407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69408   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69409   Dali::Toolkit::ControlOrientation::Type arg2 ;
69410
69411   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69412   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69413   {
69414     try {
69415       (arg1)->SetOrientation(arg2);
69416     } catch (std::out_of_range& e) {
69417       {
69418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69419       };
69420     } catch (std::exception& e) {
69421       {
69422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69423       };
69424     } catch (Dali::DaliException e) {
69425       {
69426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69427       };
69428     } catch (...) {
69429       {
69430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69431       };
69432     }
69433   }
69434
69435 }
69436
69437
69438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69439   int jresult ;
69440   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69441   Dali::Toolkit::ControlOrientation::Type result;
69442
69443   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69444   {
69445     try {
69446       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69447     } catch (std::out_of_range& e) {
69448       {
69449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69450       };
69451     } catch (std::exception& e) {
69452       {
69453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69454       };
69455     } catch (Dali::DaliException e) {
69456       {
69457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69458       };
69459     } catch (...) {
69460       {
69461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69462       };
69463     }
69464   }
69465
69466   jresult = (int)result;
69467   return jresult;
69468 }
69469
69470
69471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69472   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69473   Dali::Property::Map *arg2 = 0 ;
69474
69475   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69476   arg2 = (Dali::Property::Map *)jarg2;
69477   if (!arg2) {
69478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69479     return ;
69480   }
69481   {
69482     try {
69483       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69484     } catch (std::out_of_range& e) {
69485       {
69486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69487       };
69488     } catch (std::exception& e) {
69489       {
69490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69491       };
69492     } catch (Dali::DaliException e) {
69493       {
69494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69495       };
69496     } catch (...) {
69497       {
69498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69499       };
69500     }
69501   }
69502
69503 }
69504
69505
69506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69507   void * jresult ;
69508   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69509   Dali::Property::Map result;
69510
69511   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69512   {
69513     try {
69514       result = (arg1)->GetLayoutProperties();
69515     } catch (std::out_of_range& e) {
69516       {
69517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69518       };
69519     } catch (std::exception& e) {
69520       {
69521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69522       };
69523     } catch (Dali::DaliException e) {
69524       {
69525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69526       };
69527     } catch (...) {
69528       {
69529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69530       };
69531     }
69532   }
69533
69534   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69535   return jresult;
69536 }
69537
69538
69539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69540   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69541   unsigned int arg2 ;
69542   Dali::Vector3 *arg3 = 0 ;
69543   Dali::Vector3 *arg4 = 0 ;
69544
69545   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69546   arg2 = (unsigned int)jarg2;
69547   arg3 = (Dali::Vector3 *)jarg3;
69548   if (!arg3) {
69549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69550     return ;
69551   }
69552   arg4 = (Dali::Vector3 *)jarg4;
69553   if (!arg4) {
69554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69555     return ;
69556   }
69557   {
69558     try {
69559       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69560     } catch (std::out_of_range& e) {
69561       {
69562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69563       };
69564     } catch (std::exception& e) {
69565       {
69566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69567       };
69568     } catch (Dali::DaliException e) {
69569       {
69570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69571       };
69572     } catch (...) {
69573       {
69574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69575       };
69576     }
69577   }
69578
69579 }
69580
69581
69582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69583   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69584   Dali::Vector3 *arg2 = 0 ;
69585
69586   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69587   arg2 = (Dali::Vector3 *)jarg2;
69588   if (!arg2) {
69589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69590     return ;
69591   }
69592   {
69593     try {
69594       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69595     } catch (std::out_of_range& e) {
69596       {
69597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69598       };
69599     } catch (std::exception& e) {
69600       {
69601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69602       };
69603     } catch (Dali::DaliException e) {
69604       {
69605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69606       };
69607     } catch (...) {
69608       {
69609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69610       };
69611     }
69612   }
69613
69614 }
69615
69616
69617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69618   float jresult ;
69619   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69620   unsigned int arg2 ;
69621   Dali::Vector3 arg3 ;
69622   Dali::Vector3 *argp3 ;
69623   float result;
69624
69625   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69626   arg2 = (unsigned int)jarg2;
69627   argp3 = (Dali::Vector3 *)jarg3;
69628   if (!argp3) {
69629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69630     return 0;
69631   }
69632   arg3 = *argp3;
69633   {
69634     try {
69635       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69636     } catch (std::out_of_range& e) {
69637       {
69638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69639       };
69640     } catch (std::exception& e) {
69641       {
69642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69643       };
69644     } catch (Dali::DaliException e) {
69645       {
69646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69647       };
69648     } catch (...) {
69649       {
69650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69651       };
69652     }
69653   }
69654
69655   jresult = result;
69656   return jresult;
69657 }
69658
69659
69660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69661   float jresult ;
69662   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69663   float arg2 ;
69664   float result;
69665
69666   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69667   arg2 = (float)jarg2;
69668   {
69669     try {
69670       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69671     } catch (std::out_of_range& e) {
69672       {
69673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69674       };
69675     } catch (std::exception& e) {
69676       {
69677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69678       };
69679     } catch (Dali::DaliException e) {
69680       {
69681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69682       };
69683     } catch (...) {
69684       {
69685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69686       };
69687     }
69688   }
69689
69690   jresult = result;
69691   return jresult;
69692 }
69693
69694
69695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69696   float jresult ;
69697   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69698   unsigned int arg2 ;
69699   float result;
69700
69701   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69702   arg2 = (unsigned int)jarg2;
69703   {
69704     try {
69705       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69706     } catch (std::out_of_range& e) {
69707       {
69708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69709       };
69710     } catch (std::exception& e) {
69711       {
69712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69713       };
69714     } catch (Dali::DaliException e) {
69715       {
69716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69717       };
69718     } catch (...) {
69719       {
69720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69721       };
69722     }
69723   }
69724
69725   jresult = result;
69726   return jresult;
69727 }
69728
69729
69730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69731   void * jresult ;
69732   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69733   float arg2 ;
69734   Dali::Vector3 arg3 ;
69735   Dali::Vector3 *argp3 ;
69736   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69737
69738   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69739   arg2 = (float)jarg2;
69740   argp3 = (Dali::Vector3 *)jarg3;
69741   if (!argp3) {
69742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69743     return 0;
69744   }
69745   arg3 = *argp3;
69746   {
69747     try {
69748       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69749     } catch (std::out_of_range& e) {
69750       {
69751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69752       };
69753     } catch (std::exception& e) {
69754       {
69755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69756       };
69757     } catch (Dali::DaliException e) {
69758       {
69759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69760       };
69761     } catch (...) {
69762       {
69763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69764       };
69765     }
69766   }
69767
69768   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69769   return jresult;
69770 }
69771
69772
69773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69774   float jresult ;
69775   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69776   int arg2 ;
69777   float arg3 ;
69778   Dali::Vector3 *arg4 = 0 ;
69779   float result;
69780
69781   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69782   arg2 = (int)jarg2;
69783   arg3 = (float)jarg3;
69784   arg4 = (Dali::Vector3 *)jarg4;
69785   if (!arg4) {
69786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69787     return 0;
69788   }
69789   {
69790     try {
69791       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69792     } catch (std::out_of_range& e) {
69793       {
69794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69795       };
69796     } catch (std::exception& e) {
69797       {
69798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69799       };
69800     } catch (Dali::DaliException e) {
69801       {
69802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69803       };
69804     } catch (...) {
69805       {
69806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69807       };
69808     }
69809   }
69810
69811   jresult = result;
69812   return jresult;
69813 }
69814
69815
69816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69817   unsigned int jresult ;
69818   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69819   Dali::Vector3 arg2 ;
69820   Dali::Vector3 *argp2 ;
69821   unsigned int result;
69822
69823   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69824   argp2 = (Dali::Vector3 *)jarg2;
69825   if (!argp2) {
69826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69827     return 0;
69828   }
69829   arg2 = *argp2;
69830   {
69831     try {
69832       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69833     } catch (std::out_of_range& e) {
69834       {
69835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69836       };
69837     } catch (std::exception& e) {
69838       {
69839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69840       };
69841     } catch (Dali::DaliException e) {
69842       {
69843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69844       };
69845     } catch (...) {
69846       {
69847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69848       };
69849     }
69850   }
69851
69852   jresult = result;
69853   return jresult;
69854 }
69855
69856
69857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69858   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69859   unsigned int arg2 ;
69860   Dali::Vector3 *arg3 = 0 ;
69861   Dali::Vector3 *arg4 = 0 ;
69862
69863   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69864   arg2 = (unsigned int)jarg2;
69865   arg3 = (Dali::Vector3 *)jarg3;
69866   if (!arg3) {
69867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69868     return ;
69869   }
69870   arg4 = (Dali::Vector3 *)jarg4;
69871   if (!arg4) {
69872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69873     return ;
69874   }
69875   {
69876     try {
69877       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69878     } catch (std::out_of_range& e) {
69879       {
69880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69881       };
69882     } catch (std::exception& e) {
69883       {
69884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69885       };
69886     } catch (Dali::DaliException e) {
69887       {
69888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69889       };
69890     } catch (...) {
69891       {
69892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69893       };
69894     }
69895   }
69896
69897 }
69898
69899
69900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69901   void * jresult ;
69902   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69903   Dali::Degree result;
69904
69905   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69906   {
69907     try {
69908       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69909     } catch (std::out_of_range& e) {
69910       {
69911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69912       };
69913     } catch (std::exception& e) {
69914       {
69915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69916       };
69917     } catch (Dali::DaliException e) {
69918       {
69919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69920       };
69921     } catch (...) {
69922       {
69923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69924       };
69925     }
69926   }
69927
69928   jresult = new Dali::Degree((const Dali::Degree &)result);
69929   return jresult;
69930 }
69931
69932
69933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69934   float jresult ;
69935   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69936   float result;
69937
69938   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69939   {
69940     try {
69941       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69942     } catch (std::out_of_range& e) {
69943       {
69944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (std::exception& e) {
69947       {
69948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69949       };
69950     } catch (Dali::DaliException e) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69953       };
69954     } catch (...) {
69955       {
69956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69957       };
69958     }
69959   }
69960
69961   jresult = result;
69962   return jresult;
69963 }
69964
69965
69966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69967   float jresult ;
69968   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69969   float result;
69970
69971   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69972   {
69973     try {
69974       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69975     } catch (std::out_of_range& e) {
69976       {
69977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69978       };
69979     } catch (std::exception& e) {
69980       {
69981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69982       };
69983     } catch (Dali::DaliException e) {
69984       {
69985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69986       };
69987     } catch (...) {
69988       {
69989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69990       };
69991     }
69992   }
69993
69994   jresult = result;
69995   return jresult;
69996 }
69997
69998
69999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70000   float jresult ;
70001   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70002   float result;
70003
70004   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70005   {
70006     try {
70007       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70008     } catch (std::out_of_range& e) {
70009       {
70010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70011       };
70012     } catch (std::exception& e) {
70013       {
70014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70015       };
70016     } catch (Dali::DaliException e) {
70017       {
70018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70019       };
70020     } catch (...) {
70021       {
70022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70023       };
70024     }
70025   }
70026
70027   jresult = result;
70028   return jresult;
70029 }
70030
70031
70032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70033   int jresult ;
70034   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70035   int arg2 ;
70036   int arg3 ;
70037   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70038   bool arg5 ;
70039   int result;
70040
70041   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70042   arg2 = (int)jarg2;
70043   arg3 = (int)jarg3;
70044   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70045   arg5 = jarg5 ? true : false;
70046   {
70047     try {
70048       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70049     } catch (std::out_of_range& e) {
70050       {
70051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (std::exception& e) {
70054       {
70055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70056       };
70057     } catch (Dali::DaliException e) {
70058       {
70059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70060       };
70061     } catch (...) {
70062       {
70063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70064       };
70065     }
70066   }
70067
70068   jresult = result;
70069   return jresult;
70070 }
70071
70072
70073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70074   float jresult ;
70075   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70076   float result;
70077
70078   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70079   {
70080     try {
70081       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70082     } catch (std::out_of_range& e) {
70083       {
70084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70085       };
70086     } catch (std::exception& e) {
70087       {
70088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70089       };
70090     } catch (Dali::DaliException e) {
70091       {
70092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70093       };
70094     } catch (...) {
70095       {
70096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70097       };
70098     }
70099   }
70100
70101   jresult = result;
70102   return jresult;
70103 }
70104
70105
70106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70107   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70108   Dali::Actor *arg2 = 0 ;
70109   int arg3 ;
70110   Dali::Vector3 *arg4 = 0 ;
70111   Dali::Actor *arg5 = 0 ;
70112
70113   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70114   arg2 = (Dali::Actor *)jarg2;
70115   if (!arg2) {
70116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70117     return ;
70118   }
70119   arg3 = (int)jarg3;
70120   arg4 = (Dali::Vector3 *)jarg4;
70121   if (!arg4) {
70122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70123     return ;
70124   }
70125   arg5 = (Dali::Actor *)jarg5;
70126   if (!arg5) {
70127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70128     return ;
70129   }
70130   {
70131     try {
70132       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70133     } catch (std::out_of_range& e) {
70134       {
70135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70136       };
70137     } catch (std::exception& e) {
70138       {
70139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70140       };
70141     } catch (Dali::DaliException e) {
70142       {
70143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70144       };
70145     } catch (...) {
70146       {
70147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70148       };
70149     }
70150   }
70151
70152 }
70153
70154
70155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70156   void * jresult ;
70157   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70158   int arg2 ;
70159   float arg3 ;
70160   Dali::Vector3 *arg4 = 0 ;
70161   Dali::Vector3 result;
70162
70163   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70164   arg2 = (int)jarg2;
70165   arg3 = (float)jarg3;
70166   arg4 = (Dali::Vector3 *)jarg4;
70167   if (!arg4) {
70168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70169     return 0;
70170   }
70171   {
70172     try {
70173       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70174     } catch (std::out_of_range& e) {
70175       {
70176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70177       };
70178     } catch (std::exception& e) {
70179       {
70180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70181       };
70182     } catch (Dali::DaliException e) {
70183       {
70184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70185       };
70186     } catch (...) {
70187       {
70188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70189       };
70190     }
70191   }
70192
70193   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70194   return jresult;
70195 }
70196
70197
70198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70199   void * jresult ;
70200   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70201   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70202
70203   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70204   {
70205     try {
70206       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70207     } catch (std::out_of_range& e) {
70208       {
70209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70210       };
70211     } catch (std::exception& e) {
70212       {
70213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70214       };
70215     } catch (Dali::DaliException e) {
70216       {
70217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70218       };
70219     } catch (...) {
70220       {
70221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70222       };
70223     }
70224   }
70225
70226   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70227   return jresult;
70228 }
70229
70230
70231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70232   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70233
70234   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70235   {
70236     try {
70237       delete arg1;
70238     } catch (std::out_of_range& e) {
70239       {
70240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70241       };
70242     } catch (std::exception& e) {
70243       {
70244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70245       };
70246     } catch (Dali::DaliException e) {
70247       {
70248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70249       };
70250     } catch (...) {
70251       {
70252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70253       };
70254     }
70255   }
70256
70257 }
70258
70259
70260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70261   unsigned int jresult ;
70262   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70263   unsigned int result;
70264
70265   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70266   {
70267     try {
70268       result = (unsigned int)(arg1)->GetNumberOfItems();
70269     } catch (std::out_of_range& e) {
70270       {
70271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70272       };
70273     } catch (std::exception& e) {
70274       {
70275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70276       };
70277     } catch (Dali::DaliException e) {
70278       {
70279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70280       };
70281     } catch (...) {
70282       {
70283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70284       };
70285     }
70286   }
70287
70288   jresult = result;
70289   return jresult;
70290 }
70291
70292
70293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70294   void * jresult ;
70295   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70296   unsigned int arg2 ;
70297   Dali::Actor result;
70298
70299   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70300   arg2 = (unsigned int)jarg2;
70301   {
70302     try {
70303       result = (arg1)->NewItem(arg2);
70304     } catch (std::out_of_range& e) {
70305       {
70306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70307       };
70308     } catch (std::exception& e) {
70309       {
70310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70311       };
70312     } catch (Dali::DaliException e) {
70313       {
70314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70315       };
70316     } catch (...) {
70317       {
70318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70319       };
70320     }
70321   }
70322
70323   jresult = new Dali::Actor((const Dali::Actor &)result);
70324   return jresult;
70325 }
70326
70327
70328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70329   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70330   unsigned int arg2 ;
70331   Dali::Actor arg3 ;
70332   Dali::Actor *argp3 ;
70333
70334   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70335   arg2 = (unsigned int)jarg2;
70336   argp3 = (Dali::Actor *)jarg3;
70337   if (!argp3) {
70338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70339     return ;
70340   }
70341   arg3 = *argp3;
70342   {
70343     try {
70344       (arg1)->ItemReleased(arg2,arg3);
70345     } catch (std::out_of_range& e) {
70346       {
70347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70348       };
70349     } catch (std::exception& e) {
70350       {
70351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70352       };
70353     } catch (Dali::DaliException e) {
70354       {
70355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70356       };
70357     } catch (...) {
70358       {
70359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70360       };
70361     }
70362   }
70363
70364 }
70365
70366
70367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70368   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70369   unsigned int arg2 ;
70370   Dali::Actor arg3 ;
70371   Dali::Actor *argp3 ;
70372
70373   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70374   arg2 = (unsigned int)jarg2;
70375   argp3 = (Dali::Actor *)jarg3;
70376   if (!argp3) {
70377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70378     return ;
70379   }
70380   arg3 = *argp3;
70381   {
70382     try {
70383       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70384     } catch (std::out_of_range& e) {
70385       {
70386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70387       };
70388     } catch (std::exception& e) {
70389       {
70390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70391       };
70392     } catch (Dali::DaliException e) {
70393       {
70394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70395       };
70396     } catch (...) {
70397       {
70398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70399       };
70400     }
70401   }
70402
70403 }
70404
70405
70406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70407   void * jresult ;
70408   Dali::Toolkit::ItemFactory *result = 0 ;
70409
70410   {
70411     try {
70412       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70413     } catch (std::out_of_range& e) {
70414       {
70415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70416       };
70417     } catch (std::exception& e) {
70418       {
70419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70420       };
70421     } catch (Dali::DaliException e) {
70422       {
70423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70424       };
70425     } catch (...) {
70426       {
70427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70428       };
70429     }
70430   }
70431
70432   jresult = (void *)result;
70433   return jresult;
70434 }
70435
70436
70437 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) {
70438   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70439   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70440   if (director) {
70441     director->swig_connect_director(callback0, callback1, callback2);
70442   }
70443 }
70444
70445
70446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70447   int jresult ;
70448   int result;
70449
70450   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70451   jresult = (int)result;
70452   return jresult;
70453 }
70454
70455
70456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70457   int jresult ;
70458   int result;
70459
70460   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70461   jresult = (int)result;
70462   return jresult;
70463 }
70464
70465
70466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70467   int jresult ;
70468   int result;
70469
70470   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70471   jresult = (int)result;
70472   return jresult;
70473 }
70474
70475
70476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70477   int jresult ;
70478   int result;
70479
70480   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70481   jresult = (int)result;
70482   return jresult;
70483 }
70484
70485
70486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70487   int jresult ;
70488   int result;
70489
70490   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70491   jresult = (int)result;
70492   return jresult;
70493 }
70494
70495
70496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70497   int jresult ;
70498   int result;
70499
70500   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70501   jresult = (int)result;
70502   return jresult;
70503 }
70504
70505
70506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70507   int jresult ;
70508   int result;
70509
70510   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70511   jresult = (int)result;
70512   return jresult;
70513 }
70514
70515
70516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70517   int jresult ;
70518   int result;
70519
70520   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70521   jresult = (int)result;
70522   return jresult;
70523 }
70524
70525
70526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70527   int jresult ;
70528   int result;
70529
70530   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70531   jresult = (int)result;
70532   return jresult;
70533 }
70534
70535
70536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70537   int jresult ;
70538   int result;
70539
70540   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70541   jresult = (int)result;
70542   return jresult;
70543 }
70544
70545
70546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70547   int jresult ;
70548   int result;
70549
70550   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70551   jresult = (int)result;
70552   return jresult;
70553 }
70554
70555
70556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70557   void * jresult ;
70558   Dali::Toolkit::ItemView::Property *result = 0 ;
70559
70560   {
70561     try {
70562       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70563     } catch (std::out_of_range& e) {
70564       {
70565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70566       };
70567     } catch (std::exception& e) {
70568       {
70569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70570       };
70571     } catch (Dali::DaliException e) {
70572       {
70573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70574       };
70575     } catch (...) {
70576       {
70577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70578       };
70579     }
70580   }
70581
70582   jresult = (void *)result;
70583   return jresult;
70584 }
70585
70586
70587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70588   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70589
70590   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70591   {
70592     try {
70593       delete arg1;
70594     } catch (std::out_of_range& e) {
70595       {
70596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70597       };
70598     } catch (std::exception& e) {
70599       {
70600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70601       };
70602     } catch (Dali::DaliException e) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70605       };
70606     } catch (...) {
70607       {
70608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70609       };
70610     }
70611   }
70612
70613 }
70614
70615
70616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70617   void * jresult ;
70618   Dali::Toolkit::ItemView *result = 0 ;
70619
70620   {
70621     try {
70622       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70623     } catch (std::out_of_range& e) {
70624       {
70625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70626       };
70627     } catch (std::exception& e) {
70628       {
70629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70630       };
70631     } catch (Dali::DaliException e) {
70632       {
70633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70634       };
70635     } catch (...) {
70636       {
70637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70638       };
70639     }
70640   }
70641
70642   jresult = (void *)result;
70643   return jresult;
70644 }
70645
70646
70647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70648   void * jresult ;
70649   Dali::Toolkit::ItemView *arg1 = 0 ;
70650   Dali::Toolkit::ItemView *result = 0 ;
70651
70652   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70653   if (!arg1) {
70654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70655     return 0;
70656   }
70657   {
70658     try {
70659       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70660     } catch (std::out_of_range& e) {
70661       {
70662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70663       };
70664     } catch (std::exception& e) {
70665       {
70666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70667       };
70668     } catch (Dali::DaliException e) {
70669       {
70670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70671       };
70672     } catch (...) {
70673       {
70674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70675       };
70676     }
70677   }
70678
70679   jresult = (void *)result;
70680   return jresult;
70681 }
70682
70683
70684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70685   void * jresult ;
70686   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70687   Dali::Toolkit::ItemView *arg2 = 0 ;
70688   Dali::Toolkit::ItemView *result = 0 ;
70689
70690   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70691   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70692   if (!arg2) {
70693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70694     return 0;
70695   }
70696   {
70697     try {
70698       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70699     } catch (std::out_of_range& e) {
70700       {
70701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70702       };
70703     } catch (std::exception& e) {
70704       {
70705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70706       };
70707     } catch (Dali::DaliException e) {
70708       {
70709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70710       };
70711     } catch (...) {
70712       {
70713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70714       };
70715     }
70716   }
70717
70718   jresult = (void *)result;
70719   return jresult;
70720 }
70721
70722
70723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70724   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70725
70726   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70727   {
70728     try {
70729       delete arg1;
70730     } catch (std::out_of_range& e) {
70731       {
70732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70733       };
70734     } catch (std::exception& e) {
70735       {
70736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70737       };
70738     } catch (Dali::DaliException e) {
70739       {
70740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70741       };
70742     } catch (...) {
70743       {
70744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70745       };
70746     }
70747   }
70748
70749 }
70750
70751
70752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70753   void * jresult ;
70754   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70755   Dali::Toolkit::ItemView result;
70756
70757   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70758   if (!arg1) {
70759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70760     return 0;
70761   }
70762   {
70763     try {
70764       result = Dali::Toolkit::ItemView::New(*arg1);
70765     } catch (std::out_of_range& e) {
70766       {
70767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70768       };
70769     } catch (std::exception& e) {
70770       {
70771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70772       };
70773     } catch (Dali::DaliException e) {
70774       {
70775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70776       };
70777     } catch (...) {
70778       {
70779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70780       };
70781     }
70782   }
70783
70784   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70785   return jresult;
70786 }
70787
70788
70789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70790   void * jresult ;
70791   Dali::BaseHandle arg1 ;
70792   Dali::BaseHandle *argp1 ;
70793   Dali::Toolkit::ItemView result;
70794
70795   argp1 = (Dali::BaseHandle *)jarg1;
70796   if (!argp1) {
70797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70798     return 0;
70799   }
70800   arg1 = *argp1;
70801   {
70802     try {
70803       result = Dali::Toolkit::ItemView::DownCast(arg1);
70804     } catch (std::out_of_range& e) {
70805       {
70806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70807       };
70808     } catch (std::exception& e) {
70809       {
70810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70811       };
70812     } catch (Dali::DaliException e) {
70813       {
70814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70815       };
70816     } catch (...) {
70817       {
70818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70819       };
70820     }
70821   }
70822
70823   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70824   return jresult;
70825 }
70826
70827
70828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70829   unsigned int jresult ;
70830   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70831   unsigned int result;
70832
70833   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70834   {
70835     try {
70836       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70837     } catch (std::out_of_range& e) {
70838       {
70839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70840       };
70841     } catch (std::exception& e) {
70842       {
70843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70844       };
70845     } catch (Dali::DaliException e) {
70846       {
70847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70848       };
70849     } catch (...) {
70850       {
70851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70852       };
70853     }
70854   }
70855
70856   jresult = result;
70857   return jresult;
70858 }
70859
70860
70861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70862   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70863   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70864
70865   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70866   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70867   if (!arg2) {
70868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70869     return ;
70870   }
70871   {
70872     try {
70873       (arg1)->AddLayout(*arg2);
70874     } catch (std::out_of_range& e) {
70875       {
70876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70877       };
70878     } catch (std::exception& e) {
70879       {
70880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70881       };
70882     } catch (Dali::DaliException e) {
70883       {
70884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70885       };
70886     } catch (...) {
70887       {
70888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70889       };
70890     }
70891   }
70892
70893 }
70894
70895
70896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70897   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70898   unsigned int arg2 ;
70899
70900   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70901   arg2 = (unsigned int)jarg2;
70902   {
70903     try {
70904       (arg1)->RemoveLayout(arg2);
70905     } catch (std::out_of_range& e) {
70906       {
70907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70908       };
70909     } catch (std::exception& e) {
70910       {
70911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70912       };
70913     } catch (Dali::DaliException e) {
70914       {
70915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70916       };
70917     } catch (...) {
70918       {
70919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70920       };
70921     }
70922   }
70923
70924 }
70925
70926
70927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70928   void * jresult ;
70929   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70930   unsigned int arg2 ;
70931   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70932
70933   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70934   arg2 = (unsigned int)jarg2;
70935   {
70936     try {
70937       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70938     } catch (std::out_of_range& e) {
70939       {
70940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70941       };
70942     } catch (std::exception& e) {
70943       {
70944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70945       };
70946     } catch (Dali::DaliException e) {
70947       {
70948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70949       };
70950     } catch (...) {
70951       {
70952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70953       };
70954     }
70955   }
70956
70957   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70958   return jresult;
70959 }
70960
70961
70962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70963   void * jresult ;
70964   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70965   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70966
70967   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70968   {
70969     try {
70970       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70971     } catch (std::out_of_range& e) {
70972       {
70973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70974       };
70975     } catch (std::exception& e) {
70976       {
70977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70978       };
70979     } catch (Dali::DaliException e) {
70980       {
70981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70982       };
70983     } catch (...) {
70984       {
70985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70986       };
70987     }
70988   }
70989
70990   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70991   return jresult;
70992 }
70993
70994
70995 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70996   float jresult ;
70997   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70998   Dali::Toolkit::ItemId arg2 ;
70999   float result;
71000
71001   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71002   arg2 = (Dali::Toolkit::ItemId)jarg2;
71003   {
71004     try {
71005       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71006     } catch (std::out_of_range& e) {
71007       {
71008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71009       };
71010     } catch (std::exception& e) {
71011       {
71012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71013       };
71014     } catch (Dali::DaliException e) {
71015       {
71016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71017       };
71018     } catch (...) {
71019       {
71020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71021       };
71022     }
71023   }
71024
71025   jresult = result;
71026   return jresult;
71027 }
71028
71029
71030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71031   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71032   unsigned int arg2 ;
71033   Dali::Vector3 arg3 ;
71034   float arg4 ;
71035   Dali::Vector3 *argp3 ;
71036
71037   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71038   arg2 = (unsigned int)jarg2;
71039   argp3 = (Dali::Vector3 *)jarg3;
71040   if (!argp3) {
71041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71042     return ;
71043   }
71044   arg3 = *argp3;
71045   arg4 = (float)jarg4;
71046   {
71047     try {
71048       (arg1)->ActivateLayout(arg2,arg3,arg4);
71049     } catch (std::out_of_range& e) {
71050       {
71051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71052       };
71053     } catch (std::exception& e) {
71054       {
71055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71056       };
71057     } catch (Dali::DaliException e) {
71058       {
71059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71060       };
71061     } catch (...) {
71062       {
71063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71064       };
71065     }
71066   }
71067
71068 }
71069
71070
71071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71072   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71073
71074   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71075   {
71076     try {
71077       (arg1)->DeactivateCurrentLayout();
71078     } catch (std::out_of_range& e) {
71079       {
71080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71081       };
71082     } catch (std::exception& e) {
71083       {
71084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71085       };
71086     } catch (Dali::DaliException e) {
71087       {
71088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71089       };
71090     } catch (...) {
71091       {
71092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71093       };
71094     }
71095   }
71096
71097 }
71098
71099
71100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71101   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71102   float arg2 ;
71103
71104   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71105   arg2 = (float)jarg2;
71106   {
71107     try {
71108       (arg1)->SetMinimumSwipeSpeed(arg2);
71109     } catch (std::out_of_range& e) {
71110       {
71111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71112       };
71113     } catch (std::exception& e) {
71114       {
71115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71116       };
71117     } catch (Dali::DaliException e) {
71118       {
71119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71120       };
71121     } catch (...) {
71122       {
71123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71124       };
71125     }
71126   }
71127
71128 }
71129
71130
71131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71132   float jresult ;
71133   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71134   float result;
71135
71136   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71137   {
71138     try {
71139       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71140     } catch (std::out_of_range& e) {
71141       {
71142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71143       };
71144     } catch (std::exception& e) {
71145       {
71146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71147       };
71148     } catch (Dali::DaliException e) {
71149       {
71150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71151       };
71152     } catch (...) {
71153       {
71154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71155       };
71156     }
71157   }
71158
71159   jresult = result;
71160   return jresult;
71161 }
71162
71163
71164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71165   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71166   float arg2 ;
71167
71168   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71169   arg2 = (float)jarg2;
71170   {
71171     try {
71172       (arg1)->SetMinimumSwipeDistance(arg2);
71173     } catch (std::out_of_range& e) {
71174       {
71175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71176       };
71177     } catch (std::exception& e) {
71178       {
71179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71180       };
71181     } catch (Dali::DaliException e) {
71182       {
71183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71184       };
71185     } catch (...) {
71186       {
71187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71188       };
71189     }
71190   }
71191
71192 }
71193
71194
71195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71196   float jresult ;
71197   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71198   float result;
71199
71200   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71201   {
71202     try {
71203       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71204     } catch (std::out_of_range& e) {
71205       {
71206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71207       };
71208     } catch (std::exception& e) {
71209       {
71210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71211       };
71212     } catch (Dali::DaliException e) {
71213       {
71214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71215       };
71216     } catch (...) {
71217       {
71218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71219       };
71220     }
71221   }
71222
71223   jresult = result;
71224   return jresult;
71225 }
71226
71227
71228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71229   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71230   float arg2 ;
71231
71232   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71233   arg2 = (float)jarg2;
71234   {
71235     try {
71236       (arg1)->SetWheelScrollDistanceStep(arg2);
71237     } catch (std::out_of_range& e) {
71238       {
71239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71240       };
71241     } catch (std::exception& e) {
71242       {
71243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71244       };
71245     } catch (Dali::DaliException e) {
71246       {
71247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71248       };
71249     } catch (...) {
71250       {
71251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71252       };
71253     }
71254   }
71255
71256 }
71257
71258
71259 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71260   float jresult ;
71261   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71262   float result;
71263
71264   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71265   {
71266     try {
71267       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71268     } catch (std::out_of_range& e) {
71269       {
71270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71271       };
71272     } catch (std::exception& e) {
71273       {
71274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71275       };
71276     } catch (Dali::DaliException e) {
71277       {
71278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71279       };
71280     } catch (...) {
71281       {
71282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71283       };
71284     }
71285   }
71286
71287   jresult = result;
71288   return jresult;
71289 }
71290
71291
71292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71293   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71294   bool arg2 ;
71295
71296   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71297   arg2 = jarg2 ? true : false;
71298   {
71299     try {
71300       (arg1)->SetAnchoring(arg2);
71301     } catch (std::out_of_range& e) {
71302       {
71303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71304       };
71305     } catch (std::exception& e) {
71306       {
71307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71308       };
71309     } catch (Dali::DaliException e) {
71310       {
71311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71312       };
71313     } catch (...) {
71314       {
71315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71316       };
71317     }
71318   }
71319
71320 }
71321
71322 //// ========================= end of part 3 =============================
71323
71324 //// ========================== start part 4 ===============================
71325
71326
71327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71328   unsigned int jresult ;
71329   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71330   bool result;
71331
71332   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71333   {
71334     try {
71335       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71336     } catch (std::out_of_range& e) {
71337       {
71338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71339       };
71340     } catch (std::exception& e) {
71341       {
71342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71343       };
71344     } catch (Dali::DaliException e) {
71345       {
71346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71347       };
71348     } catch (...) {
71349       {
71350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71351       };
71352     }
71353   }
71354
71355   jresult = result;
71356   return jresult;
71357 }
71358
71359
71360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71361   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71362   float arg2 ;
71363
71364   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71365   arg2 = (float)jarg2;
71366   {
71367     try {
71368       (arg1)->SetAnchoringDuration(arg2);
71369     } catch (std::out_of_range& e) {
71370       {
71371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71372       };
71373     } catch (std::exception& e) {
71374       {
71375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71376       };
71377     } catch (Dali::DaliException e) {
71378       {
71379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71380       };
71381     } catch (...) {
71382       {
71383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71384       };
71385     }
71386   }
71387
71388 }
71389
71390
71391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71392   float jresult ;
71393   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71394   float result;
71395
71396   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71397   {
71398     try {
71399       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71400     } catch (std::out_of_range& e) {
71401       {
71402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71403       };
71404     } catch (std::exception& e) {
71405       {
71406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71407       };
71408     } catch (Dali::DaliException e) {
71409       {
71410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71411       };
71412     } catch (...) {
71413       {
71414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71415       };
71416     }
71417   }
71418
71419   jresult = result;
71420   return jresult;
71421 }
71422
71423
71424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71425   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71426   Dali::Toolkit::ItemId arg2 ;
71427   float arg3 ;
71428
71429   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71430   arg2 = (Dali::Toolkit::ItemId)jarg2;
71431   arg3 = (float)jarg3;
71432   {
71433     try {
71434       (arg1)->ScrollToItem(arg2,arg3);
71435     } catch (std::out_of_range& e) {
71436       {
71437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71438       };
71439     } catch (std::exception& e) {
71440       {
71441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71442       };
71443     } catch (Dali::DaliException e) {
71444       {
71445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71446       };
71447     } catch (...) {
71448       {
71449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71450       };
71451     }
71452   }
71453
71454 }
71455
71456
71457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71458   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71459   float arg2 ;
71460
71461   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71462   arg2 = (float)jarg2;
71463   {
71464     try {
71465       (arg1)->SetRefreshInterval(arg2);
71466     } catch (std::out_of_range& e) {
71467       {
71468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71469       };
71470     } catch (std::exception& e) {
71471       {
71472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71473       };
71474     } catch (Dali::DaliException e) {
71475       {
71476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71477       };
71478     } catch (...) {
71479       {
71480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71481       };
71482     }
71483   }
71484
71485 }
71486
71487
71488 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71489   float jresult ;
71490   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71491   float result;
71492
71493   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71494   {
71495     try {
71496       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71497     } catch (std::out_of_range& e) {
71498       {
71499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71500       };
71501     } catch (std::exception& e) {
71502       {
71503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71504       };
71505     } catch (Dali::DaliException e) {
71506       {
71507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71508       };
71509     } catch (...) {
71510       {
71511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71512       };
71513     }
71514   }
71515
71516   jresult = result;
71517   return jresult;
71518 }
71519
71520
71521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71522   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71523
71524   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71525   {
71526     try {
71527       (arg1)->Refresh();
71528     } catch (std::out_of_range& e) {
71529       {
71530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71531       };
71532     } catch (std::exception& e) {
71533       {
71534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71535       };
71536     } catch (Dali::DaliException e) {
71537       {
71538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71539       };
71540     } catch (...) {
71541       {
71542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71543       };
71544     }
71545   }
71546
71547 }
71548
71549
71550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71551   void * jresult ;
71552   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71553   Dali::Toolkit::ItemId arg2 ;
71554   Dali::Actor result;
71555
71556   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71557   arg2 = (Dali::Toolkit::ItemId)jarg2;
71558   {
71559     try {
71560       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71561     } catch (std::out_of_range& e) {
71562       {
71563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71564       };
71565     } catch (std::exception& e) {
71566       {
71567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71568       };
71569     } catch (Dali::DaliException e) {
71570       {
71571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71572       };
71573     } catch (...) {
71574       {
71575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71576       };
71577     }
71578   }
71579
71580   jresult = new Dali::Actor((const Dali::Actor &)result);
71581   return jresult;
71582 }
71583
71584
71585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71586   unsigned int jresult ;
71587   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71588   Dali::Actor arg2 ;
71589   Dali::Actor *argp2 ;
71590   Dali::Toolkit::ItemId result;
71591
71592   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71593   argp2 = (Dali::Actor *)jarg2;
71594   if (!argp2) {
71595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71596     return 0;
71597   }
71598   arg2 = *argp2;
71599   {
71600     try {
71601       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71602     } catch (std::out_of_range& e) {
71603       {
71604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71605       };
71606     } catch (std::exception& e) {
71607       {
71608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71609       };
71610     } catch (Dali::DaliException e) {
71611       {
71612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71613       };
71614     } catch (...) {
71615       {
71616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71617       };
71618     }
71619   }
71620
71621   jresult = result;
71622   return jresult;
71623 }
71624
71625
71626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71627   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71628   Dali::Toolkit::Item arg2 ;
71629   float arg3 ;
71630   Dali::Toolkit::Item *argp2 ;
71631
71632   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71633   argp2 = (Dali::Toolkit::Item *)jarg2;
71634   if (!argp2) {
71635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71636     return ;
71637   }
71638   arg2 = *argp2;
71639   arg3 = (float)jarg3;
71640   {
71641     try {
71642       (arg1)->InsertItem(arg2,arg3);
71643     } catch (std::out_of_range& e) {
71644       {
71645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71646       };
71647     } catch (std::exception& e) {
71648       {
71649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71650       };
71651     } catch (Dali::DaliException e) {
71652       {
71653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71654       };
71655     } catch (...) {
71656       {
71657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71658       };
71659     }
71660   }
71661
71662 }
71663
71664
71665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71666   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71667   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71668   float arg3 ;
71669
71670   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71671   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71672   if (!arg2) {
71673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71674     return ;
71675   }
71676   arg3 = (float)jarg3;
71677   {
71678     try {
71679       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71680     } catch (std::out_of_range& e) {
71681       {
71682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71683       };
71684     } catch (std::exception& e) {
71685       {
71686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71687       };
71688     } catch (Dali::DaliException e) {
71689       {
71690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71691       };
71692     } catch (...) {
71693       {
71694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71695       };
71696     }
71697   }
71698
71699 }
71700
71701
71702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71703   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71704   Dali::Toolkit::ItemId arg2 ;
71705   float arg3 ;
71706
71707   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71708   arg2 = (Dali::Toolkit::ItemId)jarg2;
71709   arg3 = (float)jarg3;
71710   {
71711     try {
71712       (arg1)->RemoveItem(arg2,arg3);
71713     } catch (std::out_of_range& e) {
71714       {
71715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71716       };
71717     } catch (std::exception& e) {
71718       {
71719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71720       };
71721     } catch (Dali::DaliException e) {
71722       {
71723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71724       };
71725     } catch (...) {
71726       {
71727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71728       };
71729     }
71730   }
71731
71732 }
71733
71734
71735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71736   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71737   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71738   float arg3 ;
71739
71740   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71741   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71742   if (!arg2) {
71743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71744     return ;
71745   }
71746   arg3 = (float)jarg3;
71747   {
71748     try {
71749       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71750     } catch (std::out_of_range& e) {
71751       {
71752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71753       };
71754     } catch (std::exception& e) {
71755       {
71756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71757       };
71758     } catch (Dali::DaliException e) {
71759       {
71760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71761       };
71762     } catch (...) {
71763       {
71764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71765       };
71766     }
71767   }
71768
71769 }
71770
71771
71772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71773   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71774   Dali::Toolkit::Item arg2 ;
71775   float arg3 ;
71776   Dali::Toolkit::Item *argp2 ;
71777
71778   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71779   argp2 = (Dali::Toolkit::Item *)jarg2;
71780   if (!argp2) {
71781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71782     return ;
71783   }
71784   arg2 = *argp2;
71785   arg3 = (float)jarg3;
71786   {
71787     try {
71788       (arg1)->ReplaceItem(arg2,arg3);
71789     } catch (std::out_of_range& e) {
71790       {
71791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71792       };
71793     } catch (std::exception& e) {
71794       {
71795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71796       };
71797     } catch (Dali::DaliException e) {
71798       {
71799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71800       };
71801     } catch (...) {
71802       {
71803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71804       };
71805     }
71806   }
71807
71808 }
71809
71810
71811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71812   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71813   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71814   float arg3 ;
71815
71816   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71817   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71818   if (!arg2) {
71819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71820     return ;
71821   }
71822   arg3 = (float)jarg3;
71823   {
71824     try {
71825       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71826     } catch (std::out_of_range& e) {
71827       {
71828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71829       };
71830     } catch (std::exception& e) {
71831       {
71832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71833       };
71834     } catch (Dali::DaliException e) {
71835       {
71836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71837       };
71838     } catch (...) {
71839       {
71840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71841       };
71842     }
71843   }
71844
71845 }
71846
71847
71848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71849   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71850   Dali::Vector3 *arg2 = 0 ;
71851
71852   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71853   arg2 = (Dali::Vector3 *)jarg2;
71854   if (!arg2) {
71855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71856     return ;
71857   }
71858   {
71859     try {
71860       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71861     } catch (std::out_of_range& e) {
71862       {
71863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71864       };
71865     } catch (std::exception& e) {
71866       {
71867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71868       };
71869     } catch (Dali::DaliException e) {
71870       {
71871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71872       };
71873     } catch (...) {
71874       {
71875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71876       };
71877     }
71878   }
71879
71880 }
71881
71882
71883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71884   void * jresult ;
71885   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71886   Dali::Vector3 result;
71887
71888   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71889   {
71890     try {
71891       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71892     } catch (std::out_of_range& e) {
71893       {
71894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71895       };
71896     } catch (std::exception& e) {
71897       {
71898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71899       };
71900     } catch (Dali::DaliException e) {
71901       {
71902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71903       };
71904     } catch (...) {
71905       {
71906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71907       };
71908     }
71909   }
71910
71911   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71912   return jresult;
71913 }
71914
71915
71916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71917   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71918   Dali::Vector3 *arg2 = 0 ;
71919
71920   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71921   arg2 = (Dali::Vector3 *)jarg2;
71922   if (!arg2) {
71923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71924     return ;
71925   }
71926   {
71927     try {
71928       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71929     } catch (std::out_of_range& e) {
71930       {
71931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71932       };
71933     } catch (std::exception& e) {
71934       {
71935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71936       };
71937     } catch (Dali::DaliException e) {
71938       {
71939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71940       };
71941     } catch (...) {
71942       {
71943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71944       };
71945     }
71946   }
71947
71948 }
71949
71950
71951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71952   void * jresult ;
71953   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71954   Dali::Vector3 result;
71955
71956   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71957   {
71958     try {
71959       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71960     } catch (std::out_of_range& e) {
71961       {
71962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71963       };
71964     } catch (std::exception& e) {
71965       {
71966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71967       };
71968     } catch (Dali::DaliException e) {
71969       {
71970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71971       };
71972     } catch (...) {
71973       {
71974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71975       };
71976     }
71977   }
71978
71979   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71980   return jresult;
71981 }
71982
71983
71984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71985   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71986   Dali::Toolkit::ItemRange *arg2 = 0 ;
71987
71988   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71989   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71990   if (!arg2) {
71991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71992     return ;
71993   }
71994   {
71995     try {
71996       (arg1)->GetItemsRange(*arg2);
71997     } catch (std::out_of_range& e) {
71998       {
71999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72000       };
72001     } catch (std::exception& e) {
72002       {
72003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72004       };
72005     } catch (Dali::DaliException e) {
72006       {
72007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72008       };
72009     } catch (...) {
72010       {
72011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72012       };
72013     }
72014   }
72015
72016 }
72017
72018
72019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72020   void * jresult ;
72021   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72022   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72023
72024   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72025   {
72026     try {
72027       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72028     } catch (std::out_of_range& e) {
72029       {
72030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72031       };
72032     } catch (std::exception& e) {
72033       {
72034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72035       };
72036     } catch (Dali::DaliException e) {
72037       {
72038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72039       };
72040     } catch (...) {
72041       {
72042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72043       };
72044     }
72045   }
72046
72047   jresult = (void *)result;
72048   return jresult;
72049 }
72050
72051
72052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72053   Dali::Vector3 *arg1 = 0 ;
72054   PropertyInputContainer *arg2 = 0 ;
72055
72056   arg1 = (Dali::Vector3 *)jarg1;
72057   if (!arg1) {
72058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72059     return ;
72060   }
72061   arg2 = (PropertyInputContainer *)jarg2;
72062   if (!arg2) {
72063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72064     return ;
72065   }
72066   {
72067     try {
72068       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72069     } catch (std::out_of_range& e) {
72070       {
72071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72072       };
72073     } catch (std::exception& e) {
72074       {
72075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72076       };
72077     } catch (Dali::DaliException e) {
72078       {
72079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72080       };
72081     } catch (...) {
72082       {
72083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72084       };
72085     }
72086   }
72087
72088 }
72089
72090
72091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72092   Dali::Vector3 *arg1 = 0 ;
72093   PropertyInputContainer *arg2 = 0 ;
72094
72095   arg1 = (Dali::Vector3 *)jarg1;
72096   if (!arg1) {
72097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72098     return ;
72099   }
72100   arg2 = (PropertyInputContainer *)jarg2;
72101   if (!arg2) {
72102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72103     return ;
72104   }
72105   {
72106     try {
72107       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72108     } catch (std::out_of_range& e) {
72109       {
72110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72111       };
72112     } catch (std::exception& e) {
72113       {
72114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72115       };
72116     } catch (Dali::DaliException e) {
72117       {
72118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72119       };
72120     } catch (...) {
72121       {
72122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72123       };
72124     }
72125   }
72126
72127 }
72128
72129
72130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72131   void * jresult ;
72132   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72133
72134   {
72135     try {
72136       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72137     } catch (std::out_of_range& e) {
72138       {
72139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72140       };
72141     } catch (std::exception& e) {
72142       {
72143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72144       };
72145     } catch (Dali::DaliException e) {
72146       {
72147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72148       };
72149     } catch (...) {
72150       {
72151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72152       };
72153     }
72154   }
72155
72156   jresult = (void *)result;
72157   return jresult;
72158 }
72159
72160
72161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72162   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72163
72164   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72165   {
72166     try {
72167       delete arg1;
72168     } catch (std::out_of_range& e) {
72169       {
72170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72171       };
72172     } catch (std::exception& e) {
72173       {
72174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72175       };
72176     } catch (Dali::DaliException e) {
72177       {
72178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72179       };
72180     } catch (...) {
72181       {
72182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72183       };
72184     }
72185   }
72186
72187 }
72188
72189
72190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72191   void * jresult ;
72192   Dali::Path arg1 ;
72193   Dali::Vector3 *arg2 = 0 ;
72194   Dali::Property::Index arg3 ;
72195   Dali::Vector3 *arg4 = 0 ;
72196   unsigned int arg5 ;
72197   Dali::Path *argp1 ;
72198   Dali::Toolkit::ScrollViewPagePathEffect result;
72199
72200   argp1 = (Dali::Path *)jarg1;
72201   if (!argp1) {
72202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72203     return 0;
72204   }
72205   arg1 = *argp1;
72206   arg2 = (Dali::Vector3 *)jarg2;
72207   if (!arg2) {
72208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72209     return 0;
72210   }
72211   arg3 = (Dali::Property::Index)jarg3;
72212   arg4 = (Dali::Vector3 *)jarg4;
72213   if (!arg4) {
72214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72215     return 0;
72216   }
72217   arg5 = (unsigned int)jarg5;
72218   {
72219     try {
72220       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72221     } catch (std::out_of_range& e) {
72222       {
72223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72224       };
72225     } catch (std::exception& e) {
72226       {
72227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72228       };
72229     } catch (Dali::DaliException e) {
72230       {
72231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72232       };
72233     } catch (...) {
72234       {
72235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72236       };
72237     }
72238   }
72239
72240   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72241   return jresult;
72242 }
72243
72244
72245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72246   void * jresult ;
72247   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72248
72249   {
72250     try {
72251       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72252     } catch (std::out_of_range& e) {
72253       {
72254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72255       };
72256     } catch (std::exception& e) {
72257       {
72258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72259       };
72260     } catch (Dali::DaliException e) {
72261       {
72262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72263       };
72264     } catch (...) {
72265       {
72266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72267       };
72268     }
72269   }
72270
72271   jresult = (void *)result;
72272   return jresult;
72273 }
72274
72275
72276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72277   void * jresult ;
72278   Dali::BaseHandle arg1 ;
72279   Dali::BaseHandle *argp1 ;
72280   Dali::Toolkit::ScrollViewPagePathEffect result;
72281
72282   argp1 = (Dali::BaseHandle *)jarg1;
72283   if (!argp1) {
72284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72285     return 0;
72286   }
72287   arg1 = *argp1;
72288   {
72289     try {
72290       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72291     } catch (std::out_of_range& e) {
72292       {
72293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72294       };
72295     } catch (std::exception& e) {
72296       {
72297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72298       };
72299     } catch (Dali::DaliException e) {
72300       {
72301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72302       };
72303     } catch (...) {
72304       {
72305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72306       };
72307     }
72308   }
72309
72310   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72311   return jresult;
72312 }
72313
72314
72315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72316   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72317   Dali::Actor arg2 ;
72318   unsigned int arg3 ;
72319   Dali::Actor *argp2 ;
72320
72321   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72322   argp2 = (Dali::Actor *)jarg2;
72323   if (!argp2) {
72324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72325     return ;
72326   }
72327   arg2 = *argp2;
72328   arg3 = (unsigned int)jarg3;
72329   {
72330     try {
72331       (arg1)->ApplyToPage(arg2,arg3);
72332     } catch (std::out_of_range& e) {
72333       {
72334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72335       };
72336     } catch (std::exception& e) {
72337       {
72338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72339       };
72340     } catch (Dali::DaliException e) {
72341       {
72342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72343       };
72344     } catch (...) {
72345       {
72346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72347       };
72348     }
72349   }
72350
72351 }
72352
72353
72354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72355   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72356
72357   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72358   {
72359     try {
72360       delete arg1;
72361     } catch (std::out_of_range& e) {
72362       {
72363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72364       };
72365     } catch (std::exception& e) {
72366       {
72367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72368       };
72369     } catch (Dali::DaliException e) {
72370       {
72371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72372       };
72373     } catch (...) {
72374       {
72375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72376       };
72377     }
72378   }
72379
72380 }
72381
72382
72383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72384   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72385   Dali::Toolkit::ClampState arg2 ;
72386
72387   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72388   arg2 = (Dali::Toolkit::ClampState)jarg2;
72389   if (arg1) (arg1)->x = arg2;
72390 }
72391
72392
72393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72394   int jresult ;
72395   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72396   Dali::Toolkit::ClampState result;
72397
72398   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72399   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72400   jresult = (int)result;
72401   return jresult;
72402 }
72403
72404
72405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72406   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72407   Dali::Toolkit::ClampState arg2 ;
72408
72409   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72410   arg2 = (Dali::Toolkit::ClampState)jarg2;
72411   if (arg1) (arg1)->y = arg2;
72412 }
72413
72414
72415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72416   int jresult ;
72417   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72418   Dali::Toolkit::ClampState result;
72419
72420   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72421   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72422   jresult = (int)result;
72423   return jresult;
72424 }
72425
72426
72427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72428   void * jresult ;
72429   Dali::Toolkit::ClampState2D *result = 0 ;
72430
72431   {
72432     try {
72433       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72434     } catch (std::out_of_range& e) {
72435       {
72436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72437       };
72438     } catch (std::exception& e) {
72439       {
72440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72441       };
72442     } catch (Dali::DaliException e) {
72443       {
72444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72445       };
72446     } catch (...) {
72447       {
72448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72449       };
72450     }
72451   }
72452
72453   jresult = (void *)result;
72454   return jresult;
72455 }
72456
72457
72458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72459   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72460
72461   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72462   {
72463     try {
72464       delete arg1;
72465     } catch (std::out_of_range& e) {
72466       {
72467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72468       };
72469     } catch (std::exception& e) {
72470       {
72471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72472       };
72473     } catch (Dali::DaliException e) {
72474       {
72475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72476       };
72477     } catch (...) {
72478       {
72479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72480       };
72481     }
72482   }
72483
72484 }
72485
72486
72487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72488   void * jresult ;
72489   float arg1 ;
72490   float arg2 ;
72491   bool arg3 ;
72492   Dali::Toolkit::RulerDomain *result = 0 ;
72493
72494   arg1 = (float)jarg1;
72495   arg2 = (float)jarg2;
72496   arg3 = jarg3 ? true : false;
72497   {
72498     try {
72499       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72500     } catch (std::out_of_range& e) {
72501       {
72502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72503       };
72504     } catch (std::exception& e) {
72505       {
72506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72507       };
72508     } catch (Dali::DaliException e) {
72509       {
72510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72511       };
72512     } catch (...) {
72513       {
72514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72515       };
72516     }
72517   }
72518
72519   jresult = (void *)result;
72520   return jresult;
72521 }
72522
72523
72524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72525   void * jresult ;
72526   float arg1 ;
72527   float arg2 ;
72528   Dali::Toolkit::RulerDomain *result = 0 ;
72529
72530   arg1 = (float)jarg1;
72531   arg2 = (float)jarg2;
72532   {
72533     try {
72534       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72535     } catch (std::out_of_range& e) {
72536       {
72537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72538       };
72539     } catch (std::exception& e) {
72540       {
72541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72542       };
72543     } catch (Dali::DaliException e) {
72544       {
72545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72546       };
72547     } catch (...) {
72548       {
72549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72550       };
72551     }
72552   }
72553
72554   jresult = (void *)result;
72555   return jresult;
72556 }
72557
72558
72559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72560   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72561   float arg2 ;
72562
72563   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72564   arg2 = (float)jarg2;
72565   if (arg1) (arg1)->min = arg2;
72566 }
72567
72568
72569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72570   float jresult ;
72571   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72572   float result;
72573
72574   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72575   result = (float) ((arg1)->min);
72576   jresult = result;
72577   return jresult;
72578 }
72579
72580
72581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72582   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72583   float arg2 ;
72584
72585   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72586   arg2 = (float)jarg2;
72587   if (arg1) (arg1)->max = arg2;
72588 }
72589
72590
72591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72592   float jresult ;
72593   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72594   float result;
72595
72596   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72597   result = (float) ((arg1)->max);
72598   jresult = result;
72599   return jresult;
72600 }
72601
72602
72603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72604   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72605   bool arg2 ;
72606
72607   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72608   arg2 = jarg2 ? true : false;
72609   if (arg1) (arg1)->enabled = arg2;
72610 }
72611
72612
72613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72614   unsigned int jresult ;
72615   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72616   bool result;
72617
72618   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72619   result = (bool) ((arg1)->enabled);
72620   jresult = result;
72621   return jresult;
72622 }
72623
72624
72625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72626   float jresult ;
72627   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72628   float arg2 ;
72629   float arg3 ;
72630   float arg4 ;
72631   float result;
72632
72633   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72634   arg2 = (float)jarg2;
72635   arg3 = (float)jarg3;
72636   arg4 = (float)jarg4;
72637   {
72638     try {
72639       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72640     } catch (std::out_of_range& e) {
72641       {
72642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72643       };
72644     } catch (std::exception& e) {
72645       {
72646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72647       };
72648     } catch (Dali::DaliException e) {
72649       {
72650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72651       };
72652     } catch (...) {
72653       {
72654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72655       };
72656     }
72657   }
72658
72659   jresult = result;
72660   return jresult;
72661 }
72662
72663
72664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72665   float jresult ;
72666   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72667   float arg2 ;
72668   float arg3 ;
72669   float result;
72670
72671   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72672   arg2 = (float)jarg2;
72673   arg3 = (float)jarg3;
72674   {
72675     try {
72676       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72677     } catch (std::out_of_range& e) {
72678       {
72679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72680       };
72681     } catch (std::exception& e) {
72682       {
72683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72684       };
72685     } catch (Dali::DaliException e) {
72686       {
72687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72688       };
72689     } catch (...) {
72690       {
72691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72692       };
72693     }
72694   }
72695
72696   jresult = result;
72697   return jresult;
72698 }
72699
72700
72701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72702   float jresult ;
72703   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72704   float arg2 ;
72705   float result;
72706
72707   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72708   arg2 = (float)jarg2;
72709   {
72710     try {
72711       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72712     } catch (std::out_of_range& e) {
72713       {
72714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72715       };
72716     } catch (std::exception& e) {
72717       {
72718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72719       };
72720     } catch (Dali::DaliException e) {
72721       {
72722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72723       };
72724     } catch (...) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72727       };
72728     }
72729   }
72730
72731   jresult = result;
72732   return jresult;
72733 }
72734
72735
72736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72737   float jresult ;
72738   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72739   float arg2 ;
72740   float arg3 ;
72741   float arg4 ;
72742   Dali::Toolkit::ClampState *arg5 = 0 ;
72743   float result;
72744
72745   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72746   arg2 = (float)jarg2;
72747   arg3 = (float)jarg3;
72748   arg4 = (float)jarg4;
72749   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72750   if (!arg5) {
72751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72752     return 0;
72753   }
72754   {
72755     try {
72756       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72757     } catch (std::out_of_range& e) {
72758       {
72759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72760       };
72761     } catch (std::exception& e) {
72762       {
72763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72764       };
72765     } catch (Dali::DaliException e) {
72766       {
72767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72768       };
72769     } catch (...) {
72770       {
72771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72772       };
72773     }
72774   }
72775
72776   jresult = result;
72777   return jresult;
72778 }
72779
72780
72781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72782   float jresult ;
72783   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72784   float result;
72785
72786   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72787   {
72788     try {
72789       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72790     } catch (std::out_of_range& e) {
72791       {
72792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72793       };
72794     } catch (std::exception& e) {
72795       {
72796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72797       };
72798     } catch (Dali::DaliException e) {
72799       {
72800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72801       };
72802     } catch (...) {
72803       {
72804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72805       };
72806     }
72807   }
72808
72809   jresult = result;
72810   return jresult;
72811 }
72812
72813
72814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72815   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72816
72817   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72818   {
72819     try {
72820       delete arg1;
72821     } catch (std::out_of_range& e) {
72822       {
72823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72824       };
72825     } catch (std::exception& e) {
72826       {
72827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72828       };
72829     } catch (Dali::DaliException e) {
72830       {
72831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72832       };
72833     } catch (...) {
72834       {
72835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72836       };
72837     }
72838   }
72839
72840 }
72841
72842
72843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72844   float jresult ;
72845   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72846   float arg2 ;
72847   float arg3 ;
72848   float result;
72849
72850   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72851   arg2 = (float)jarg2;
72852   arg3 = (float)jarg3;
72853   {
72854     try {
72855       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72856     } catch (std::out_of_range& e) {
72857       {
72858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72859       };
72860     } catch (std::exception& e) {
72861       {
72862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72863       };
72864     } catch (Dali::DaliException e) {
72865       {
72866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72867       };
72868     } catch (...) {
72869       {
72870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72871       };
72872     }
72873   }
72874
72875   jresult = result;
72876   return jresult;
72877 }
72878
72879
72880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72881   float jresult ;
72882   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72883   float arg2 ;
72884   float result;
72885
72886   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72887   arg2 = (float)jarg2;
72888   {
72889     try {
72890       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72891     } catch (std::out_of_range& e) {
72892       {
72893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72894       };
72895     } catch (std::exception& e) {
72896       {
72897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72898       };
72899     } catch (Dali::DaliException e) {
72900       {
72901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72902       };
72903     } catch (...) {
72904       {
72905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72906       };
72907     }
72908   }
72909
72910   jresult = result;
72911   return jresult;
72912 }
72913
72914
72915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72916   float jresult ;
72917   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72918   unsigned int arg2 ;
72919   unsigned int *arg3 = 0 ;
72920   bool arg4 ;
72921   float result;
72922
72923   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72924   arg2 = (unsigned int)jarg2;
72925   arg3 = (unsigned int *)jarg3;
72926   arg4 = jarg4 ? true : false;
72927   {
72928     try {
72929       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72930     } catch (std::out_of_range& e) {
72931       {
72932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72933       };
72934     } catch (std::exception& e) {
72935       {
72936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72937       };
72938     } catch (Dali::DaliException e) {
72939       {
72940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72941       };
72942     } catch (...) {
72943       {
72944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72945       };
72946     }
72947   }
72948
72949   jresult = result;
72950   return jresult;
72951 }
72952
72953
72954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72955   unsigned int jresult ;
72956   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72957   float arg2 ;
72958   bool arg3 ;
72959   unsigned int result;
72960
72961   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72962   arg2 = (float)jarg2;
72963   arg3 = jarg3 ? true : false;
72964   {
72965     try {
72966       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72967     } catch (std::out_of_range& e) {
72968       {
72969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72970       };
72971     } catch (std::exception& e) {
72972       {
72973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72974       };
72975     } catch (Dali::DaliException e) {
72976       {
72977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72978       };
72979     } catch (...) {
72980       {
72981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72982       };
72983     }
72984   }
72985
72986   jresult = result;
72987   return jresult;
72988 }
72989
72990
72991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72992   unsigned int jresult ;
72993   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72994   unsigned int result;
72995
72996   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72997   {
72998     try {
72999       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
73000     } catch (std::out_of_range& e) {
73001       {
73002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73003       };
73004     } catch (std::exception& e) {
73005       {
73006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73007       };
73008     } catch (Dali::DaliException e) {
73009       {
73010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73011       };
73012     } catch (...) {
73013       {
73014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73015       };
73016     }
73017   }
73018
73019   jresult = result;
73020   return jresult;
73021 }
73022
73023
73024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
73025   int jresult ;
73026   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73027   Dali::Toolkit::Ruler::RulerType result;
73028
73029   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73030   {
73031     try {
73032       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
73033     } catch (std::out_of_range& e) {
73034       {
73035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73036       };
73037     } catch (std::exception& e) {
73038       {
73039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73040       };
73041     } catch (Dali::DaliException e) {
73042       {
73043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73044       };
73045     } catch (...) {
73046       {
73047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73048       };
73049     }
73050   }
73051
73052   jresult = (int)result;
73053   return jresult;
73054 }
73055
73056
73057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
73058   unsigned int jresult ;
73059   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73060   bool result;
73061
73062   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73063   {
73064     try {
73065       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
73066     } catch (std::out_of_range& e) {
73067       {
73068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73069       };
73070     } catch (std::exception& e) {
73071       {
73072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73073       };
73074     } catch (Dali::DaliException e) {
73075       {
73076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73077       };
73078     } catch (...) {
73079       {
73080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73081       };
73082     }
73083   }
73084
73085   jresult = result;
73086   return jresult;
73087 }
73088
73089
73090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
73091   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73092
73093   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73094   {
73095     try {
73096       (arg1)->Enable();
73097     } catch (std::out_of_range& e) {
73098       {
73099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73100       };
73101     } catch (std::exception& e) {
73102       {
73103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73104       };
73105     } catch (Dali::DaliException e) {
73106       {
73107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73108       };
73109     } catch (...) {
73110       {
73111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73112       };
73113     }
73114   }
73115
73116 }
73117
73118
73119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73120   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73121
73122   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73123   {
73124     try {
73125       (arg1)->Disable();
73126     } catch (std::out_of_range& e) {
73127       {
73128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73129       };
73130     } catch (std::exception& e) {
73131       {
73132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73133       };
73134     } catch (Dali::DaliException e) {
73135       {
73136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73137       };
73138     } catch (...) {
73139       {
73140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73141       };
73142     }
73143   }
73144
73145 }
73146
73147
73148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73149   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73150   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73151   Dali::Toolkit::RulerDomain *argp2 ;
73152
73153   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73154   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73155   if (!argp2) {
73156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73157     return ;
73158   }
73159   arg2 = *argp2;
73160   {
73161     try {
73162       (arg1)->SetDomain(arg2);
73163     } catch (std::out_of_range& e) {
73164       {
73165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73166       };
73167     } catch (std::exception& e) {
73168       {
73169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73170       };
73171     } catch (Dali::DaliException e) {
73172       {
73173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73174       };
73175     } catch (...) {
73176       {
73177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73178       };
73179     }
73180   }
73181
73182 }
73183
73184
73185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73186   void * jresult ;
73187   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73188   Dali::Toolkit::RulerDomain *result = 0 ;
73189
73190   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73191   {
73192     try {
73193       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73194     } catch (std::out_of_range& e) {
73195       {
73196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73197       };
73198     } catch (std::exception& e) {
73199       {
73200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73201       };
73202     } catch (Dali::DaliException e) {
73203       {
73204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73205       };
73206     } catch (...) {
73207       {
73208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73209       };
73210     }
73211   }
73212
73213   jresult = (void *)result;
73214   return jresult;
73215 }
73216
73217
73218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73219   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73220
73221   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73222   {
73223     try {
73224       (arg1)->DisableDomain();
73225     } catch (std::out_of_range& e) {
73226       {
73227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73228       };
73229     } catch (std::exception& e) {
73230       {
73231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73232       };
73233     } catch (Dali::DaliException e) {
73234       {
73235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73236       };
73237     } catch (...) {
73238       {
73239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73240       };
73241     }
73242   }
73243
73244 }
73245
73246
73247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73248   float jresult ;
73249   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73250   float arg2 ;
73251   float arg3 ;
73252   float arg4 ;
73253   float result;
73254
73255   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73256   arg2 = (float)jarg2;
73257   arg3 = (float)jarg3;
73258   arg4 = (float)jarg4;
73259   {
73260     try {
73261       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73262     } catch (std::out_of_range& e) {
73263       {
73264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73265       };
73266     } catch (std::exception& e) {
73267       {
73268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73269       };
73270     } catch (Dali::DaliException e) {
73271       {
73272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73273       };
73274     } catch (...) {
73275       {
73276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73277       };
73278     }
73279   }
73280
73281   jresult = result;
73282   return jresult;
73283 }
73284
73285
73286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73287   float jresult ;
73288   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73289   float arg2 ;
73290   float arg3 ;
73291   float result;
73292
73293   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73294   arg2 = (float)jarg2;
73295   arg3 = (float)jarg3;
73296   {
73297     try {
73298       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73299     } catch (std::out_of_range& e) {
73300       {
73301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73302       };
73303     } catch (std::exception& e) {
73304       {
73305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73306       };
73307     } catch (Dali::DaliException e) {
73308       {
73309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73310       };
73311     } catch (...) {
73312       {
73313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73314       };
73315     }
73316   }
73317
73318   jresult = result;
73319   return jresult;
73320 }
73321
73322
73323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73324   float jresult ;
73325   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73326   float arg2 ;
73327   float result;
73328
73329   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73330   arg2 = (float)jarg2;
73331   {
73332     try {
73333       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73334     } catch (std::out_of_range& e) {
73335       {
73336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73337       };
73338     } catch (std::exception& e) {
73339       {
73340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73341       };
73342     } catch (Dali::DaliException e) {
73343       {
73344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73345       };
73346     } catch (...) {
73347       {
73348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73349       };
73350     }
73351   }
73352
73353   jresult = result;
73354   return jresult;
73355 }
73356
73357
73358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73359   float jresult ;
73360   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73361   float arg2 ;
73362   float arg3 ;
73363   float arg4 ;
73364   Dali::Toolkit::ClampState *arg5 = 0 ;
73365   float result;
73366
73367   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73368   arg2 = (float)jarg2;
73369   arg3 = (float)jarg3;
73370   arg4 = (float)jarg4;
73371   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73372   if (!arg5) {
73373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73374     return 0;
73375   }
73376   {
73377     try {
73378       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73379     } catch (std::out_of_range& e) {
73380       {
73381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73382       };
73383     } catch (std::exception& e) {
73384       {
73385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73386       };
73387     } catch (Dali::DaliException e) {
73388       {
73389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73390       };
73391     } catch (...) {
73392       {
73393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73394       };
73395     }
73396   }
73397
73398   jresult = result;
73399   return jresult;
73400 }
73401
73402
73403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73404   float jresult ;
73405   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73406   float arg2 ;
73407   float arg3 ;
73408   float arg4 ;
73409   float arg5 ;
73410   float result;
73411
73412   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73413   arg2 = (float)jarg2;
73414   arg3 = (float)jarg3;
73415   arg4 = (float)jarg4;
73416   arg5 = (float)jarg5;
73417   {
73418     try {
73419       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73420     } catch (std::out_of_range& e) {
73421       {
73422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73423       };
73424     } catch (std::exception& e) {
73425       {
73426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73427       };
73428     } catch (Dali::DaliException e) {
73429       {
73430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73431       };
73432     } catch (...) {
73433       {
73434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73435       };
73436     }
73437   }
73438
73439   jresult = result;
73440   return jresult;
73441 }
73442
73443
73444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73445   float jresult ;
73446   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73447   float arg2 ;
73448   float arg3 ;
73449   float arg4 ;
73450   float result;
73451
73452   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73453   arg2 = (float)jarg2;
73454   arg3 = (float)jarg3;
73455   arg4 = (float)jarg4;
73456   {
73457     try {
73458       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73459     } catch (std::out_of_range& e) {
73460       {
73461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73462       };
73463     } catch (std::exception& e) {
73464       {
73465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73466       };
73467     } catch (Dali::DaliException e) {
73468       {
73469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73470       };
73471     } catch (...) {
73472       {
73473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73474       };
73475     }
73476   }
73477
73478   jresult = result;
73479   return jresult;
73480 }
73481
73482
73483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73484   float jresult ;
73485   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73486   float arg2 ;
73487   float arg3 ;
73488   float result;
73489
73490   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73491   arg2 = (float)jarg2;
73492   arg3 = (float)jarg3;
73493   {
73494     try {
73495       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73496     } catch (std::out_of_range& e) {
73497       {
73498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73499       };
73500     } catch (std::exception& e) {
73501       {
73502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73503       };
73504     } catch (Dali::DaliException e) {
73505       {
73506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73507       };
73508     } catch (...) {
73509       {
73510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73511       };
73512     }
73513   }
73514
73515   jresult = result;
73516   return jresult;
73517 }
73518
73519
73520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73521   float jresult ;
73522   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73523   float arg2 ;
73524   float result;
73525
73526   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73527   arg2 = (float)jarg2;
73528   {
73529     try {
73530       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73531     } catch (std::out_of_range& e) {
73532       {
73533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73534       };
73535     } catch (std::exception& e) {
73536       {
73537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73538       };
73539     } catch (Dali::DaliException e) {
73540       {
73541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73542       };
73543     } catch (...) {
73544       {
73545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73546       };
73547     }
73548   }
73549
73550   jresult = result;
73551   return jresult;
73552 }
73553
73554
73555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73556   float jresult ;
73557   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73558   float arg2 ;
73559   float arg3 ;
73560   float arg4 ;
73561   float arg5 ;
73562   Dali::Toolkit::ClampState *arg6 = 0 ;
73563   float result;
73564
73565   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73566   arg2 = (float)jarg2;
73567   arg3 = (float)jarg3;
73568   arg4 = (float)jarg4;
73569   arg5 = (float)jarg5;
73570   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73571   if (!arg6) {
73572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73573     return 0;
73574   }
73575   {
73576     try {
73577       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73578     } catch (std::out_of_range& e) {
73579       {
73580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73581       };
73582     } catch (std::exception& e) {
73583       {
73584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73585       };
73586     } catch (Dali::DaliException e) {
73587       {
73588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73589       };
73590     } catch (...) {
73591       {
73592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73593       };
73594     }
73595   }
73596
73597   jresult = result;
73598   return jresult;
73599 }
73600
73601
73602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73603   void * jresult ;
73604   Dali::Toolkit::DefaultRuler *result = 0 ;
73605
73606   {
73607     try {
73608       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73609     } catch (std::out_of_range& e) {
73610       {
73611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73612       };
73613     } catch (std::exception& e) {
73614       {
73615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73616       };
73617     } catch (Dali::DaliException e) {
73618       {
73619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73620       };
73621     } catch (...) {
73622       {
73623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73624       };
73625     }
73626   }
73627
73628   jresult = (void *)result;
73629   return jresult;
73630 }
73631
73632
73633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73634   float jresult ;
73635   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73636   float arg2 ;
73637   float arg3 ;
73638   float result;
73639
73640   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73641   arg2 = (float)jarg2;
73642   arg3 = (float)jarg3;
73643   {
73644     try {
73645       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73646     } catch (std::out_of_range& e) {
73647       {
73648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73649       };
73650     } catch (std::exception& e) {
73651       {
73652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73653       };
73654     } catch (Dali::DaliException e) {
73655       {
73656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73657       };
73658     } catch (...) {
73659       {
73660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73661       };
73662     }
73663   }
73664
73665   jresult = result;
73666   return jresult;
73667 }
73668
73669
73670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73671   float jresult ;
73672   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73673   unsigned int arg2 ;
73674   unsigned int *arg3 = 0 ;
73675   bool arg4 ;
73676   float result;
73677
73678   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73679   arg2 = (unsigned int)jarg2;
73680   arg3 = (unsigned int *)jarg3;
73681   arg4 = jarg4 ? true : false;
73682   {
73683     try {
73684       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73685     } catch (std::out_of_range& e) {
73686       {
73687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73688       };
73689     } catch (std::exception& e) {
73690       {
73691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73692       };
73693     } catch (Dali::DaliException e) {
73694       {
73695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73696       };
73697     } catch (...) {
73698       {
73699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73700       };
73701     }
73702   }
73703
73704   jresult = result;
73705   return jresult;
73706 }
73707
73708
73709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73710   unsigned int jresult ;
73711   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73712   float arg2 ;
73713   bool arg3 ;
73714   unsigned int result;
73715
73716   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73717   arg2 = (float)jarg2;
73718   arg3 = jarg3 ? true : false;
73719   {
73720     try {
73721       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73722     } catch (std::out_of_range& e) {
73723       {
73724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73725       };
73726     } catch (std::exception& e) {
73727       {
73728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73729       };
73730     } catch (Dali::DaliException e) {
73731       {
73732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73733       };
73734     } catch (...) {
73735       {
73736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73737       };
73738     }
73739   }
73740
73741   jresult = result;
73742   return jresult;
73743 }
73744
73745
73746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73747   unsigned int jresult ;
73748   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73749   unsigned int result;
73750
73751   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73752   {
73753     try {
73754       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73755     } catch (std::out_of_range& e) {
73756       {
73757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73758       };
73759     } catch (std::exception& e) {
73760       {
73761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73762       };
73763     } catch (Dali::DaliException e) {
73764       {
73765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73766       };
73767     } catch (...) {
73768       {
73769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73770       };
73771     }
73772   }
73773
73774   jresult = result;
73775   return jresult;
73776 }
73777
73778
73779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73780   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73781
73782   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73783   {
73784     try {
73785       delete arg1;
73786     } catch (std::out_of_range& e) {
73787       {
73788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73789       };
73790     } catch (std::exception& e) {
73791       {
73792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73793       };
73794     } catch (Dali::DaliException e) {
73795       {
73796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73797       };
73798     } catch (...) {
73799       {
73800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73801       };
73802     }
73803   }
73804
73805 }
73806
73807
73808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73809   void * jresult ;
73810   float arg1 ;
73811   Dali::Toolkit::FixedRuler *result = 0 ;
73812
73813   arg1 = (float)jarg1;
73814   {
73815     try {
73816       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73817     } catch (std::out_of_range& e) {
73818       {
73819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73820       };
73821     } catch (std::exception& e) {
73822       {
73823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73824       };
73825     } catch (Dali::DaliException e) {
73826       {
73827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73828       };
73829     } catch (...) {
73830       {
73831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73832       };
73833     }
73834   }
73835
73836   jresult = (void *)result;
73837   return jresult;
73838 }
73839
73840
73841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73842   void * jresult ;
73843   Dali::Toolkit::FixedRuler *result = 0 ;
73844
73845   {
73846     try {
73847       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73848     } catch (std::out_of_range& e) {
73849       {
73850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73851       };
73852     } catch (std::exception& e) {
73853       {
73854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73855       };
73856     } catch (Dali::DaliException e) {
73857       {
73858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73859       };
73860     } catch (...) {
73861       {
73862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73863       };
73864     }
73865   }
73866
73867   jresult = (void *)result;
73868   return jresult;
73869 }
73870
73871
73872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73873   float jresult ;
73874   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73875   float arg2 ;
73876   float arg3 ;
73877   float result;
73878
73879   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73880   arg2 = (float)jarg2;
73881   arg3 = (float)jarg3;
73882   {
73883     try {
73884       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73885     } catch (std::out_of_range& e) {
73886       {
73887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73888       };
73889     } catch (std::exception& e) {
73890       {
73891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73892       };
73893     } catch (Dali::DaliException e) {
73894       {
73895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73896       };
73897     } catch (...) {
73898       {
73899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73900       };
73901     }
73902   }
73903
73904   jresult = result;
73905   return jresult;
73906 }
73907
73908
73909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73910   float jresult ;
73911   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73912   unsigned int arg2 ;
73913   unsigned int *arg3 = 0 ;
73914   bool arg4 ;
73915   float result;
73916
73917   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73918   arg2 = (unsigned int)jarg2;
73919   arg3 = (unsigned int *)jarg3;
73920   arg4 = jarg4 ? true : false;
73921   {
73922     try {
73923       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73924     } catch (std::out_of_range& e) {
73925       {
73926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73927       };
73928     } catch (std::exception& e) {
73929       {
73930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73931       };
73932     } catch (Dali::DaliException e) {
73933       {
73934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73935       };
73936     } catch (...) {
73937       {
73938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73939       };
73940     }
73941   }
73942
73943   jresult = result;
73944   return jresult;
73945 }
73946
73947
73948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73949   unsigned int jresult ;
73950   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73951   float arg2 ;
73952   bool arg3 ;
73953   unsigned int result;
73954
73955   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73956   arg2 = (float)jarg2;
73957   arg3 = jarg3 ? true : false;
73958   {
73959     try {
73960       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73961     } catch (std::out_of_range& e) {
73962       {
73963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73964       };
73965     } catch (std::exception& e) {
73966       {
73967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73968       };
73969     } catch (Dali::DaliException e) {
73970       {
73971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73972       };
73973     } catch (...) {
73974       {
73975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73976       };
73977     }
73978   }
73979
73980   jresult = result;
73981   return jresult;
73982 }
73983
73984
73985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73986   unsigned int jresult ;
73987   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73988   unsigned int result;
73989
73990   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73991   {
73992     try {
73993       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73994     } catch (std::out_of_range& e) {
73995       {
73996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73997       };
73998     } catch (std::exception& e) {
73999       {
74000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74001       };
74002     } catch (Dali::DaliException e) {
74003       {
74004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74005       };
74006     } catch (...) {
74007       {
74008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74009       };
74010     }
74011   }
74012
74013   jresult = result;
74014   return jresult;
74015 }
74016
74017
74018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
74019   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74020
74021   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74022   {
74023     try {
74024       delete arg1;
74025     } catch (std::out_of_range& e) {
74026       {
74027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74028       };
74029     } catch (std::exception& e) {
74030       {
74031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74032       };
74033     } catch (Dali::DaliException e) {
74034       {
74035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74036       };
74037     } catch (...) {
74038       {
74039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74040       };
74041     }
74042   }
74043
74044 }
74045
74046
74047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
74048   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74049   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74050
74051   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74052   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74053   if (arg1) (arg1)->scale = *arg2;
74054 }
74055
74056
74057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
74058   void * jresult ;
74059   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74060   Dali::Toolkit::ClampState2D *result = 0 ;
74061
74062   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74063   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
74064   jresult = (void *)result;
74065   return jresult;
74066 }
74067
74068
74069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
74070   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74071   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74072
74073   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74074   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74075   if (arg1) (arg1)->position = *arg2;
74076 }
74077
74078
74079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
74080   void * jresult ;
74081   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74082   Dali::Toolkit::ClampState2D *result = 0 ;
74083
74084   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74085   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
74086   jresult = (void *)result;
74087   return jresult;
74088 }
74089
74090
74091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
74092   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74093   Dali::Toolkit::ClampState arg2 ;
74094
74095   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74096   arg2 = (Dali::Toolkit::ClampState)jarg2;
74097   if (arg1) (arg1)->rotation = arg2;
74098 }
74099
74100
74101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
74102   int jresult ;
74103   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74104   Dali::Toolkit::ClampState result;
74105
74106   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74107   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
74108   jresult = (int)result;
74109   return jresult;
74110 }
74111
74112
74113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
74114   void * jresult ;
74115   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
74116
74117   {
74118     try {
74119       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
74120     } catch (std::out_of_range& e) {
74121       {
74122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74123       };
74124     } catch (std::exception& e) {
74125       {
74126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74127       };
74128     } catch (Dali::DaliException e) {
74129       {
74130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74131       };
74132     } catch (...) {
74133       {
74134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74135       };
74136     }
74137   }
74138
74139   jresult = (void *)result;
74140   return jresult;
74141 }
74142
74143
74144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
74145   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74146
74147   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74148   {
74149     try {
74150       delete arg1;
74151     } catch (std::out_of_range& e) {
74152       {
74153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74154       };
74155     } catch (std::exception& e) {
74156       {
74157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74158       };
74159     } catch (Dali::DaliException e) {
74160       {
74161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74162       };
74163     } catch (...) {
74164       {
74165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74166       };
74167     }
74168   }
74169
74170 }
74171
74172
74173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
74174   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74175   Dali::Toolkit::SnapType arg2 ;
74176
74177   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74178   arg2 = (Dali::Toolkit::SnapType)jarg2;
74179   if (arg1) (arg1)->type = arg2;
74180 }
74181
74182
74183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74184   int jresult ;
74185   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74186   Dali::Toolkit::SnapType result;
74187
74188   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74189   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74190   jresult = (int)result;
74191   return jresult;
74192 }
74193
74194
74195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74196   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74197   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74198
74199   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74200   arg2 = (Dali::Vector2 *)jarg2;
74201   if (arg1) (arg1)->position = *arg2;
74202 }
74203
74204
74205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74206   void * jresult ;
74207   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74208   Dali::Vector2 *result = 0 ;
74209
74210   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74211   result = (Dali::Vector2 *)& ((arg1)->position);
74212   jresult = (void *)result;
74213   return jresult;
74214 }
74215
74216
74217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74218   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74219   float arg2 ;
74220
74221   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74222   arg2 = (float)jarg2;
74223   if (arg1) (arg1)->duration = arg2;
74224 }
74225
74226
74227 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74228   float jresult ;
74229   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74230   float result;
74231
74232   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74233   result = (float) ((arg1)->duration);
74234   jresult = result;
74235   return jresult;
74236 }
74237
74238
74239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74240   void * jresult ;
74241   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74242
74243   {
74244     try {
74245       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74246     } catch (std::out_of_range& e) {
74247       {
74248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74249       };
74250     } catch (std::exception& e) {
74251       {
74252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74253       };
74254     } catch (Dali::DaliException e) {
74255       {
74256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74257       };
74258     } catch (...) {
74259       {
74260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74261       };
74262     }
74263   }
74264
74265   jresult = (void *)result;
74266   return jresult;
74267 }
74268
74269
74270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74271   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74272
74273   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74274   {
74275     try {
74276       delete arg1;
74277     } catch (std::out_of_range& e) {
74278       {
74279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74280       };
74281     } catch (std::exception& e) {
74282       {
74283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74284       };
74285     } catch (Dali::DaliException e) {
74286       {
74287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74288       };
74289     } catch (...) {
74290       {
74291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74292       };
74293     }
74294   }
74295
74296 }
74297
74298
74299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74300   int jresult ;
74301   int result;
74302
74303   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74304   jresult = (int)result;
74305   return jresult;
74306 }
74307
74308
74309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74310   int jresult ;
74311   int result;
74312
74313   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74314   jresult = (int)result;
74315   return jresult;
74316 }
74317
74318
74319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74320   int jresult ;
74321   int result;
74322
74323   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74324   jresult = (int)result;
74325   return jresult;
74326 }
74327
74328
74329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74330   int jresult ;
74331   int result;
74332
74333   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74334   jresult = (int)result;
74335   return jresult;
74336 }
74337
74338
74339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74340   int jresult ;
74341   int result;
74342
74343   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74344   jresult = (int)result;
74345   return jresult;
74346 }
74347
74348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74349   int jresult ;
74350   int result;
74351
74352   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74353   jresult = (int)result;
74354   return jresult;
74355 }
74356
74357
74358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74359   int jresult ;
74360   int result;
74361
74362   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74363   jresult = (int)result;
74364   return jresult;
74365 }
74366
74367
74368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74369   int jresult ;
74370   int result;
74371
74372   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74373   jresult = (int)result;
74374   return jresult;
74375 }
74376
74377
74378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74379   int jresult ;
74380   int result;
74381
74382   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74383   jresult = (int)result;
74384   return jresult;
74385 }
74386
74387
74388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74389   int jresult ;
74390   int result;
74391
74392   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74393   jresult = (int)result;
74394   return jresult;
74395 }
74396
74397
74398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74399   int jresult ;
74400   int result;
74401
74402   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74403   jresult = (int)result;
74404   return jresult;
74405 }
74406
74407
74408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74409   int jresult ;
74410   int result;
74411
74412   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74413   jresult = (int)result;
74414   return jresult;
74415 }
74416
74417
74418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74419   int jresult ;
74420   int result;
74421
74422   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74423   jresult = (int)result;
74424   return jresult;
74425 }
74426
74427
74428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74429   int jresult ;
74430   int result;
74431
74432   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74433   jresult = (int)result;
74434   return jresult;
74435 }
74436
74437
74438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74439   int jresult ;
74440   int result;
74441
74442   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74443   jresult = (int)result;
74444   return jresult;
74445 }
74446
74447
74448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74449   int jresult ;
74450   int result;
74451
74452   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74453   jresult = (int)result;
74454   return jresult;
74455 }
74456
74457
74458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74459   int jresult ;
74460   int result;
74461
74462   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74463   jresult = (int)result;
74464   return jresult;
74465 }
74466
74467
74468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74469   int jresult ;
74470   int result;
74471
74472   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74473   jresult = (int)result;
74474   return jresult;
74475 }
74476
74477
74478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74479   int jresult ;
74480   int result;
74481
74482   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74483   jresult = (int)result;
74484   return jresult;
74485 }
74486
74487
74488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74489   int jresult ;
74490   int result;
74491
74492   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74493   jresult = (int)result;
74494   return jresult;
74495 }
74496
74497
74498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74499   int jresult ;
74500   int result;
74501
74502   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74503   jresult = (int)result;
74504   return jresult;
74505 }
74506
74507
74508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74509   int jresult ;
74510   int result;
74511
74512   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74513   jresult = (int)result;
74514   return jresult;
74515 }
74516
74517
74518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74519   int jresult ;
74520   int result;
74521
74522   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74523   jresult = (int)result;
74524   return jresult;
74525 }
74526
74527
74528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74529   int jresult ;
74530   int result;
74531
74532   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74533   jresult = (int)result;
74534   return jresult;
74535 }
74536
74537
74538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74539   int jresult ;
74540   int result;
74541
74542   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74543   jresult = (int)result;
74544   return jresult;
74545 }
74546
74547
74548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74549   int jresult ;
74550   int result;
74551
74552   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74553   jresult = (int)result;
74554   return jresult;
74555 }
74556
74557
74558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74559   void * jresult ;
74560   Dali::Toolkit::ScrollView::Property *result = 0 ;
74561
74562   {
74563     try {
74564       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74565     } catch (std::out_of_range& e) {
74566       {
74567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74568       };
74569     } catch (std::exception& e) {
74570       {
74571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74572       };
74573     } catch (Dali::DaliException e) {
74574       {
74575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74576       };
74577     } catch (...) {
74578       {
74579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74580       };
74581     }
74582   }
74583
74584   jresult = (void *)result;
74585   return jresult;
74586 }
74587
74588
74589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74590   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74591
74592   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74593   {
74594     try {
74595       delete arg1;
74596     } catch (std::out_of_range& e) {
74597       {
74598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74599       };
74600     } catch (std::exception& e) {
74601       {
74602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74603       };
74604     } catch (Dali::DaliException e) {
74605       {
74606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74607       };
74608     } catch (...) {
74609       {
74610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74611       };
74612     }
74613   }
74614
74615 }
74616
74617
74618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74619   void * jresult ;
74620   Dali::Toolkit::ScrollView *result = 0 ;
74621
74622   {
74623     try {
74624       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74625     } catch (std::out_of_range& e) {
74626       {
74627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74628       };
74629     } catch (std::exception& e) {
74630       {
74631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74632       };
74633     } catch (Dali::DaliException e) {
74634       {
74635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74636       };
74637     } catch (...) {
74638       {
74639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74640       };
74641     }
74642   }
74643
74644   jresult = (void *)result;
74645   return jresult;
74646 }
74647
74648
74649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74650   void * jresult ;
74651   Dali::Toolkit::ScrollView *arg1 = 0 ;
74652   Dali::Toolkit::ScrollView *result = 0 ;
74653
74654   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74655   if (!arg1) {
74656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74657     return 0;
74658   }
74659   {
74660     try {
74661       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74662     } catch (std::out_of_range& e) {
74663       {
74664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74665       };
74666     } catch (std::exception& e) {
74667       {
74668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74669       };
74670     } catch (Dali::DaliException e) {
74671       {
74672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74673       };
74674     } catch (...) {
74675       {
74676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74677       };
74678     }
74679   }
74680
74681   jresult = (void *)result;
74682   return jresult;
74683 }
74684
74685
74686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74687   void * jresult ;
74688   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74689   Dali::Toolkit::ScrollView *arg2 = 0 ;
74690   Dali::Toolkit::ScrollView *result = 0 ;
74691
74692   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74693   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74694   if (!arg2) {
74695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74696     return 0;
74697   }
74698   {
74699     try {
74700       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74701     } catch (std::out_of_range& e) {
74702       {
74703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74704       };
74705     } catch (std::exception& e) {
74706       {
74707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74708       };
74709     } catch (Dali::DaliException e) {
74710       {
74711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74712       };
74713     } catch (...) {
74714       {
74715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74716       };
74717     }
74718   }
74719
74720   jresult = (void *)result;
74721   return jresult;
74722 }
74723
74724
74725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74726   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74727
74728   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74729   {
74730     try {
74731       delete arg1;
74732     } catch (std::out_of_range& e) {
74733       {
74734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74735       };
74736     } catch (std::exception& e) {
74737       {
74738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74739       };
74740     } catch (Dali::DaliException e) {
74741       {
74742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74743       };
74744     } catch (...) {
74745       {
74746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74747       };
74748     }
74749   }
74750
74751 }
74752
74753
74754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74755   void * jresult ;
74756   Dali::Toolkit::ScrollView result;
74757
74758   {
74759     try {
74760       result = Dali::Toolkit::ScrollView::New();
74761     } catch (std::out_of_range& e) {
74762       {
74763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74764       };
74765     } catch (std::exception& e) {
74766       {
74767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74768       };
74769     } catch (Dali::DaliException e) {
74770       {
74771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74772       };
74773     } catch (...) {
74774       {
74775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74776       };
74777     }
74778   }
74779
74780   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74781   return jresult;
74782 }
74783
74784
74785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74786   void * jresult ;
74787   Dali::BaseHandle arg1 ;
74788   Dali::BaseHandle *argp1 ;
74789   Dali::Toolkit::ScrollView result;
74790
74791   argp1 = (Dali::BaseHandle *)jarg1;
74792   if (!argp1) {
74793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74794     return 0;
74795   }
74796   arg1 = *argp1;
74797   {
74798     try {
74799       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74800     } catch (std::out_of_range& e) {
74801       {
74802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74803       };
74804     } catch (std::exception& e) {
74805       {
74806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74807       };
74808     } catch (Dali::DaliException e) {
74809       {
74810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74811       };
74812     } catch (...) {
74813       {
74814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74815       };
74816     }
74817   }
74818
74819   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74820   return jresult;
74821 }
74822
74823
74824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74825   void * jresult ;
74826   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74827   Dali::AlphaFunction result;
74828
74829   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74830   {
74831     try {
74832       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74833     } catch (std::out_of_range& e) {
74834       {
74835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74836       };
74837     } catch (std::exception& e) {
74838       {
74839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74840       };
74841     } catch (Dali::DaliException e) {
74842       {
74843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74844       };
74845     } catch (...) {
74846       {
74847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74848       };
74849     }
74850   }
74851
74852   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74853   return jresult;
74854 }
74855
74856
74857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74858   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74859   Dali::AlphaFunction arg2 ;
74860   Dali::AlphaFunction *argp2 ;
74861
74862   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74863   argp2 = (Dali::AlphaFunction *)jarg2;
74864   if (!argp2) {
74865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74866     return ;
74867   }
74868   arg2 = *argp2;
74869   {
74870     try {
74871       (arg1)->SetScrollSnapAlphaFunction(arg2);
74872     } catch (std::out_of_range& e) {
74873       {
74874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74875       };
74876     } catch (std::exception& e) {
74877       {
74878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74879       };
74880     } catch (Dali::DaliException e) {
74881       {
74882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74883       };
74884     } catch (...) {
74885       {
74886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74887       };
74888     }
74889   }
74890
74891 }
74892
74893
74894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74895   void * jresult ;
74896   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74897   Dali::AlphaFunction result;
74898
74899   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74900   {
74901     try {
74902       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74903     } catch (std::out_of_range& e) {
74904       {
74905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74906       };
74907     } catch (std::exception& e) {
74908       {
74909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74910       };
74911     } catch (Dali::DaliException e) {
74912       {
74913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74914       };
74915     } catch (...) {
74916       {
74917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74918       };
74919     }
74920   }
74921
74922   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74923   return jresult;
74924 }
74925
74926
74927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74928   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74929   Dali::AlphaFunction arg2 ;
74930   Dali::AlphaFunction *argp2 ;
74931
74932   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74933   argp2 = (Dali::AlphaFunction *)jarg2;
74934   if (!argp2) {
74935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74936     return ;
74937   }
74938   arg2 = *argp2;
74939   {
74940     try {
74941       (arg1)->SetScrollFlickAlphaFunction(arg2);
74942     } catch (std::out_of_range& e) {
74943       {
74944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74945       };
74946     } catch (std::exception& e) {
74947       {
74948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74949       };
74950     } catch (Dali::DaliException e) {
74951       {
74952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74953       };
74954     } catch (...) {
74955       {
74956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74957       };
74958     }
74959   }
74960
74961 }
74962
74963
74964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74965   float jresult ;
74966   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74967   float result;
74968
74969   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74970   {
74971     try {
74972       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74973     } catch (std::out_of_range& e) {
74974       {
74975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74976       };
74977     } catch (std::exception& e) {
74978       {
74979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74980       };
74981     } catch (Dali::DaliException e) {
74982       {
74983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74984       };
74985     } catch (...) {
74986       {
74987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74988       };
74989     }
74990   }
74991
74992   jresult = result;
74993   return jresult;
74994 }
74995
74996
74997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74998   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74999   float arg2 ;
75000
75001   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75002   arg2 = (float)jarg2;
75003   {
75004     try {
75005       (arg1)->SetScrollSnapDuration(arg2);
75006     } catch (std::out_of_range& e) {
75007       {
75008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75009       };
75010     } catch (std::exception& e) {
75011       {
75012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75013       };
75014     } catch (Dali::DaliException e) {
75015       {
75016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75017       };
75018     } catch (...) {
75019       {
75020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75021       };
75022     }
75023   }
75024
75025 }
75026
75027
75028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
75029   float jresult ;
75030   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75031   float result;
75032
75033   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75034   {
75035     try {
75036       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
75037     } catch (std::out_of_range& e) {
75038       {
75039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75040       };
75041     } catch (std::exception& e) {
75042       {
75043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75044       };
75045     } catch (Dali::DaliException e) {
75046       {
75047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75048       };
75049     } catch (...) {
75050       {
75051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75052       };
75053     }
75054   }
75055
75056   jresult = result;
75057   return jresult;
75058 }
75059
75060
75061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
75062   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75063   float arg2 ;
75064
75065   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75066   arg2 = (float)jarg2;
75067   {
75068     try {
75069       (arg1)->SetScrollFlickDuration(arg2);
75070     } catch (std::out_of_range& e) {
75071       {
75072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75073       };
75074     } catch (std::exception& e) {
75075       {
75076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75077       };
75078     } catch (Dali::DaliException e) {
75079       {
75080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75081       };
75082     } catch (...) {
75083       {
75084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75085       };
75086     }
75087   }
75088
75089 }
75090
75091
75092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
75093   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75094   Dali::Toolkit::RulerPtr arg2 ;
75095   Dali::Toolkit::RulerPtr *argp2 ;
75096
75097   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75098   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75099   if (!argp2) {
75100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75101     return ;
75102   }
75103   arg2 = *argp2;
75104   {
75105     try {
75106       (arg1)->SetRulerX(arg2);
75107     } catch (std::out_of_range& e) {
75108       {
75109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75110       };
75111     } catch (std::exception& e) {
75112       {
75113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75114       };
75115     } catch (Dali::DaliException e) {
75116       {
75117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75118       };
75119     } catch (...) {
75120       {
75121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75122       };
75123     }
75124   }
75125
75126 }
75127
75128
75129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
75130   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75131   Dali::Toolkit::RulerPtr arg2 ;
75132   Dali::Toolkit::RulerPtr *argp2 ;
75133
75134   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75135   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75136   if (!argp2) {
75137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75138     return ;
75139   }
75140   arg2 = *argp2;
75141   {
75142     try {
75143       (arg1)->SetRulerY(arg2);
75144     } catch (std::out_of_range& e) {
75145       {
75146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75147       };
75148     } catch (std::exception& e) {
75149       {
75150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75151       };
75152     } catch (Dali::DaliException e) {
75153       {
75154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75155       };
75156     } catch (...) {
75157       {
75158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75159       };
75160     }
75161   }
75162
75163 }
75164
75165
75166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
75167   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75168   bool arg2 ;
75169
75170   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75171   arg2 = jarg2 ? true : false;
75172   {
75173     try {
75174       (arg1)->SetScrollSensitive(arg2);
75175     } catch (std::out_of_range& e) {
75176       {
75177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75178       };
75179     } catch (std::exception& e) {
75180       {
75181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75182       };
75183     } catch (Dali::DaliException e) {
75184       {
75185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75186       };
75187     } catch (...) {
75188       {
75189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75190       };
75191     }
75192   }
75193
75194 }
75195
75196
75197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75198   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75199   float arg2 ;
75200   float arg3 ;
75201
75202   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75203   arg2 = (float)jarg2;
75204   arg3 = (float)jarg3;
75205   {
75206     try {
75207       (arg1)->SetMaxOvershoot(arg2,arg3);
75208     } catch (std::out_of_range& e) {
75209       {
75210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75211       };
75212     } catch (std::exception& e) {
75213       {
75214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75215       };
75216     } catch (Dali::DaliException e) {
75217       {
75218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75219       };
75220     } catch (...) {
75221       {
75222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75223       };
75224     }
75225   }
75226
75227 }
75228
75229
75230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75231   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75232   Dali::AlphaFunction arg2 ;
75233   Dali::AlphaFunction *argp2 ;
75234
75235   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75236   argp2 = (Dali::AlphaFunction *)jarg2;
75237   if (!argp2) {
75238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75239     return ;
75240   }
75241   arg2 = *argp2;
75242   {
75243     try {
75244       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75245     } catch (std::out_of_range& e) {
75246       {
75247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75248       };
75249     } catch (std::exception& e) {
75250       {
75251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75252       };
75253     } catch (Dali::DaliException e) {
75254       {
75255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75256       };
75257     } catch (...) {
75258       {
75259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75260       };
75261     }
75262   }
75263
75264 }
75265
75266
75267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75268   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75269   float arg2 ;
75270
75271   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75272   arg2 = (float)jarg2;
75273   {
75274     try {
75275       (arg1)->SetSnapOvershootDuration(arg2);
75276     } catch (std::out_of_range& e) {
75277       {
75278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75279       };
75280     } catch (std::exception& e) {
75281       {
75282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75283       };
75284     } catch (Dali::DaliException e) {
75285       {
75286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75287       };
75288     } catch (...) {
75289       {
75290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75291       };
75292     }
75293   }
75294
75295 }
75296
75297
75298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75299   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75300   bool arg2 ;
75301
75302   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75303   arg2 = jarg2 ? true : false;
75304   {
75305     try {
75306       (arg1)->SetActorAutoSnap(arg2);
75307     } catch (std::out_of_range& e) {
75308       {
75309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75310       };
75311     } catch (std::exception& e) {
75312       {
75313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75314       };
75315     } catch (Dali::DaliException e) {
75316       {
75317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75318       };
75319     } catch (...) {
75320       {
75321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75322       };
75323     }
75324   }
75325
75326 }
75327
75328
75329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75330   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75331   bool arg2 ;
75332
75333   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75334   arg2 = jarg2 ? true : false;
75335   {
75336     try {
75337       (arg1)->SetWrapMode(arg2);
75338     } catch (std::out_of_range& e) {
75339       {
75340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75341       };
75342     } catch (std::exception& e) {
75343       {
75344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75345       };
75346     } catch (Dali::DaliException e) {
75347       {
75348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75349       };
75350     } catch (...) {
75351       {
75352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75353       };
75354     }
75355   }
75356
75357 }
75358
75359
75360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75361   int jresult ;
75362   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75363   int result;
75364
75365   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75366   {
75367     try {
75368       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75369     } catch (std::out_of_range& e) {
75370       {
75371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75372       };
75373     } catch (std::exception& e) {
75374       {
75375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75376       };
75377     } catch (Dali::DaliException e) {
75378       {
75379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75380       };
75381     } catch (...) {
75382       {
75383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75384       };
75385     }
75386   }
75387
75388   jresult = result;
75389   return jresult;
75390 }
75391
75392
75393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75394   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75395   int arg2 ;
75396
75397   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75398   arg2 = (int)jarg2;
75399   {
75400     try {
75401       (arg1)->SetScrollUpdateDistance(arg2);
75402     } catch (std::out_of_range& e) {
75403       {
75404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75405       };
75406     } catch (std::exception& e) {
75407       {
75408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75409       };
75410     } catch (Dali::DaliException e) {
75411       {
75412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75413       };
75414     } catch (...) {
75415       {
75416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75417       };
75418     }
75419   }
75420
75421 }
75422
75423
75424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75425   unsigned int jresult ;
75426   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75427   bool result;
75428
75429   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75430   {
75431     try {
75432       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75433     } catch (std::out_of_range& e) {
75434       {
75435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75436       };
75437     } catch (std::exception& e) {
75438       {
75439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75440       };
75441     } catch (Dali::DaliException e) {
75442       {
75443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75444       };
75445     } catch (...) {
75446       {
75447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75448       };
75449     }
75450   }
75451
75452   jresult = result;
75453   return jresult;
75454 }
75455
75456
75457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75458   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75459   bool arg2 ;
75460
75461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75462   arg2 = jarg2 ? true : false;
75463   {
75464     try {
75465       (arg1)->SetAxisAutoLock(arg2);
75466     } catch (std::out_of_range& e) {
75467       {
75468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75469       };
75470     } catch (std::exception& e) {
75471       {
75472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75473       };
75474     } catch (Dali::DaliException e) {
75475       {
75476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75477       };
75478     } catch (...) {
75479       {
75480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75481       };
75482     }
75483   }
75484
75485 }
75486
75487
75488 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75489   float jresult ;
75490   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75491   float result;
75492
75493   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75494   {
75495     try {
75496       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75497     } catch (std::out_of_range& e) {
75498       {
75499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75500       };
75501     } catch (std::exception& e) {
75502       {
75503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75504       };
75505     } catch (Dali::DaliException e) {
75506       {
75507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75508       };
75509     } catch (...) {
75510       {
75511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75512       };
75513     }
75514   }
75515
75516   jresult = result;
75517   return jresult;
75518 }
75519
75520
75521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75522   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75523   float arg2 ;
75524
75525   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75526   arg2 = (float)jarg2;
75527   {
75528     try {
75529       (arg1)->SetAxisAutoLockGradient(arg2);
75530     } catch (std::out_of_range& e) {
75531       {
75532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75533       };
75534     } catch (std::exception& e) {
75535       {
75536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75537       };
75538     } catch (Dali::DaliException e) {
75539       {
75540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75541       };
75542     } catch (...) {
75543       {
75544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75545       };
75546     }
75547   }
75548
75549 }
75550
75551
75552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75553   float jresult ;
75554   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75555   float result;
75556
75557   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75558   {
75559     try {
75560       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75561     } catch (std::out_of_range& e) {
75562       {
75563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75564       };
75565     } catch (std::exception& e) {
75566       {
75567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75568       };
75569     } catch (Dali::DaliException e) {
75570       {
75571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75572       };
75573     } catch (...) {
75574       {
75575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75576       };
75577     }
75578   }
75579
75580   jresult = result;
75581   return jresult;
75582 }
75583
75584
75585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75586   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75587   float arg2 ;
75588
75589   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75590   arg2 = (float)jarg2;
75591   {
75592     try {
75593       (arg1)->SetFrictionCoefficient(arg2);
75594     } catch (std::out_of_range& e) {
75595       {
75596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75597       };
75598     } catch (std::exception& e) {
75599       {
75600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75601       };
75602     } catch (Dali::DaliException e) {
75603       {
75604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75605       };
75606     } catch (...) {
75607       {
75608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75609       };
75610     }
75611   }
75612
75613 }
75614
75615
75616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75617   float jresult ;
75618   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75619   float result;
75620
75621   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75622   {
75623     try {
75624       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75625     } catch (std::out_of_range& e) {
75626       {
75627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75628       };
75629     } catch (std::exception& e) {
75630       {
75631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75632       };
75633     } catch (Dali::DaliException e) {
75634       {
75635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75636       };
75637     } catch (...) {
75638       {
75639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75640       };
75641     }
75642   }
75643
75644   jresult = result;
75645   return jresult;
75646 }
75647
75648
75649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75650   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75651   float arg2 ;
75652
75653   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75654   arg2 = (float)jarg2;
75655   {
75656     try {
75657       (arg1)->SetFlickSpeedCoefficient(arg2);
75658     } catch (std::out_of_range& e) {
75659       {
75660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75661       };
75662     } catch (std::exception& e) {
75663       {
75664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75665       };
75666     } catch (Dali::DaliException e) {
75667       {
75668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75669       };
75670     } catch (...) {
75671       {
75672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75673       };
75674     }
75675   }
75676
75677 }
75678
75679
75680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75681   void * jresult ;
75682   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75683   Dali::Vector2 result;
75684
75685   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75686   {
75687     try {
75688       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75689     } catch (std::out_of_range& e) {
75690       {
75691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75692       };
75693     } catch (std::exception& e) {
75694       {
75695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75696       };
75697     } catch (Dali::DaliException e) {
75698       {
75699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75700       };
75701     } catch (...) {
75702       {
75703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75704       };
75705     }
75706   }
75707
75708   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75709   return jresult;
75710 }
75711
75712
75713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75714   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75715   Dali::Vector2 *arg2 = 0 ;
75716
75717   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75718   arg2 = (Dali::Vector2 *)jarg2;
75719   if (!arg2) {
75720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75721     return ;
75722   }
75723   {
75724     try {
75725       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75726     } catch (std::out_of_range& e) {
75727       {
75728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75729       };
75730     } catch (std::exception& e) {
75731       {
75732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75733       };
75734     } catch (Dali::DaliException e) {
75735       {
75736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75737       };
75738     } catch (...) {
75739       {
75740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75741       };
75742     }
75743   }
75744
75745 }
75746
75747
75748 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75749   float jresult ;
75750   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75751   float result;
75752
75753   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75754   {
75755     try {
75756       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75757     } catch (std::out_of_range& e) {
75758       {
75759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75760       };
75761     } catch (std::exception& e) {
75762       {
75763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75764       };
75765     } catch (Dali::DaliException e) {
75766       {
75767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75768       };
75769     } catch (...) {
75770       {
75771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75772       };
75773     }
75774   }
75775
75776   jresult = result;
75777   return jresult;
75778 }
75779
75780
75781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75782   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75783   float arg2 ;
75784
75785   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75786   arg2 = (float)jarg2;
75787   {
75788     try {
75789       (arg1)->SetMinimumSpeedForFlick(arg2);
75790     } catch (std::out_of_range& e) {
75791       {
75792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75793       };
75794     } catch (std::exception& e) {
75795       {
75796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75797       };
75798     } catch (Dali::DaliException e) {
75799       {
75800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75801       };
75802     } catch (...) {
75803       {
75804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75805       };
75806     }
75807   }
75808
75809 }
75810
75811
75812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75813   float jresult ;
75814   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75815   float result;
75816
75817   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75818   {
75819     try {
75820       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75821     } catch (std::out_of_range& e) {
75822       {
75823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75824       };
75825     } catch (std::exception& e) {
75826       {
75827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75828       };
75829     } catch (Dali::DaliException e) {
75830       {
75831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75832       };
75833     } catch (...) {
75834       {
75835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75836       };
75837     }
75838   }
75839
75840   jresult = result;
75841   return jresult;
75842 }
75843
75844
75845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75846   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75847   float arg2 ;
75848
75849   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75850   arg2 = (float)jarg2;
75851   {
75852     try {
75853       (arg1)->SetMaxFlickSpeed(arg2);
75854     } catch (std::out_of_range& e) {
75855       {
75856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75857       };
75858     } catch (std::exception& e) {
75859       {
75860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75861       };
75862     } catch (Dali::DaliException e) {
75863       {
75864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75865       };
75866     } catch (...) {
75867       {
75868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75869       };
75870     }
75871   }
75872
75873 }
75874
75875
75876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75877   void * jresult ;
75878   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75879   Dali::Vector2 result;
75880
75881   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75882   {
75883     try {
75884       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75885     } catch (std::out_of_range& e) {
75886       {
75887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75888       };
75889     } catch (std::exception& e) {
75890       {
75891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75892       };
75893     } catch (Dali::DaliException e) {
75894       {
75895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75896       };
75897     } catch (...) {
75898       {
75899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75900       };
75901     }
75902   }
75903
75904   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75905   return jresult;
75906 }
75907
75908
75909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75911   Dali::Vector2 arg2 ;
75912   Dali::Vector2 *argp2 ;
75913
75914   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75915   argp2 = (Dali::Vector2 *)jarg2;
75916   if (!argp2) {
75917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75918     return ;
75919   }
75920   arg2 = *argp2;
75921   {
75922     try {
75923       (arg1)->SetWheelScrollDistanceStep(arg2);
75924     } catch (std::out_of_range& e) {
75925       {
75926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75927       };
75928     } catch (std::exception& e) {
75929       {
75930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75931       };
75932     } catch (Dali::DaliException e) {
75933       {
75934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75935       };
75936     } catch (...) {
75937       {
75938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75939       };
75940     }
75941   }
75942
75943 }
75944
75945
75946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75947   void * jresult ;
75948   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75949   Dali::Vector2 result;
75950
75951   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75952   {
75953     try {
75954       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75955     } catch (std::out_of_range& e) {
75956       {
75957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75958       };
75959     } catch (std::exception& e) {
75960       {
75961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75962       };
75963     } catch (Dali::DaliException e) {
75964       {
75965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75966       };
75967     } catch (...) {
75968       {
75969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75970       };
75971     }
75972   }
75973
75974   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75975   return jresult;
75976 }
75977
75978
75979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75980   unsigned int jresult ;
75981   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75982   unsigned int result;
75983
75984   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75985   {
75986     try {
75987       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75988     } catch (std::out_of_range& e) {
75989       {
75990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75991       };
75992     } catch (std::exception& e) {
75993       {
75994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75995       };
75996     } catch (Dali::DaliException e) {
75997       {
75998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75999       };
76000     } catch (...) {
76001       {
76002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76003       };
76004     }
76005   }
76006
76007   jresult = result;
76008   return jresult;
76009 }
76010
76011
76012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
76013   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76014   Dali::Vector2 *arg2 = 0 ;
76015
76016   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76017   arg2 = (Dali::Vector2 *)jarg2;
76018   if (!arg2) {
76019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76020     return ;
76021   }
76022   {
76023     try {
76024       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
76025     } catch (std::out_of_range& e) {
76026       {
76027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76028       };
76029     } catch (std::exception& e) {
76030       {
76031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76032       };
76033     } catch (Dali::DaliException e) {
76034       {
76035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76036       };
76037     } catch (...) {
76038       {
76039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76040       };
76041     }
76042   }
76043
76044 }
76045
76046
76047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
76048   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76049   Dali::Vector2 *arg2 = 0 ;
76050   float arg3 ;
76051
76052   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76053   arg2 = (Dali::Vector2 *)jarg2;
76054   if (!arg2) {
76055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76056     return ;
76057   }
76058   arg3 = (float)jarg3;
76059   {
76060     try {
76061       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
76062     } catch (std::out_of_range& e) {
76063       {
76064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76065       };
76066     } catch (std::exception& e) {
76067       {
76068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76069       };
76070     } catch (Dali::DaliException e) {
76071       {
76072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76073       };
76074     } catch (...) {
76075       {
76076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76077       };
76078     }
76079   }
76080
76081 }
76082
76083
76084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
76085   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76086   Dali::Vector2 *arg2 = 0 ;
76087   float arg3 ;
76088   Dali::AlphaFunction arg4 ;
76089   Dali::AlphaFunction *argp4 ;
76090
76091   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76092   arg2 = (Dali::Vector2 *)jarg2;
76093   if (!arg2) {
76094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76095     return ;
76096   }
76097   arg3 = (float)jarg3;
76098   argp4 = (Dali::AlphaFunction *)jarg4;
76099   if (!argp4) {
76100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76101     return ;
76102   }
76103   arg4 = *argp4;
76104   {
76105     try {
76106       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
76107     } catch (std::out_of_range& e) {
76108       {
76109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76110       };
76111     } catch (std::exception& e) {
76112       {
76113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76114       };
76115     } catch (Dali::DaliException e) {
76116       {
76117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76118       };
76119     } catch (...) {
76120       {
76121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76122       };
76123     }
76124   }
76125
76126 }
76127
76128
76129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
76130   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76131   Dali::Vector2 *arg2 = 0 ;
76132   float arg3 ;
76133   Dali::Toolkit::DirectionBias arg4 ;
76134   Dali::Toolkit::DirectionBias arg5 ;
76135
76136   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76137   arg2 = (Dali::Vector2 *)jarg2;
76138   if (!arg2) {
76139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76140     return ;
76141   }
76142   arg3 = (float)jarg3;
76143   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76144   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76145   {
76146     try {
76147       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
76148     } catch (std::out_of_range& e) {
76149       {
76150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76151       };
76152     } catch (std::exception& e) {
76153       {
76154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76155       };
76156     } catch (Dali::DaliException e) {
76157       {
76158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76159       };
76160     } catch (...) {
76161       {
76162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76163       };
76164     }
76165   }
76166
76167 }
76168
76169
76170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
76171   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76172   Dali::Vector2 *arg2 = 0 ;
76173   float arg3 ;
76174   Dali::AlphaFunction arg4 ;
76175   Dali::Toolkit::DirectionBias arg5 ;
76176   Dali::Toolkit::DirectionBias arg6 ;
76177   Dali::AlphaFunction *argp4 ;
76178
76179   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76180   arg2 = (Dali::Vector2 *)jarg2;
76181   if (!arg2) {
76182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76183     return ;
76184   }
76185   arg3 = (float)jarg3;
76186   argp4 = (Dali::AlphaFunction *)jarg4;
76187   if (!argp4) {
76188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76189     return ;
76190   }
76191   arg4 = *argp4;
76192   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76193   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76194   {
76195     try {
76196       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76197     } catch (std::out_of_range& e) {
76198       {
76199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76200       };
76201     } catch (std::exception& e) {
76202       {
76203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76204       };
76205     } catch (Dali::DaliException e) {
76206       {
76207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76208       };
76209     } catch (...) {
76210       {
76211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76212       };
76213     }
76214   }
76215
76216 }
76217
76218
76219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76220   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76221   unsigned int arg2 ;
76222
76223   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76224   arg2 = (unsigned int)jarg2;
76225   {
76226     try {
76227       (arg1)->ScrollTo(arg2);
76228     } catch (std::out_of_range& e) {
76229       {
76230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76231       };
76232     } catch (std::exception& e) {
76233       {
76234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76235       };
76236     } catch (Dali::DaliException e) {
76237       {
76238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76239       };
76240     } catch (...) {
76241       {
76242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76243       };
76244     }
76245   }
76246
76247 }
76248
76249
76250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76251   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76252   unsigned int arg2 ;
76253   float arg3 ;
76254
76255   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76256   arg2 = (unsigned int)jarg2;
76257   arg3 = (float)jarg3;
76258   {
76259     try {
76260       (arg1)->ScrollTo(arg2,arg3);
76261     } catch (std::out_of_range& e) {
76262       {
76263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76264       };
76265     } catch (std::exception& e) {
76266       {
76267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76268       };
76269     } catch (Dali::DaliException e) {
76270       {
76271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76272       };
76273     } catch (...) {
76274       {
76275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76276       };
76277     }
76278   }
76279
76280 }
76281
76282
76283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76284   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76285   unsigned int arg2 ;
76286   float arg3 ;
76287   Dali::Toolkit::DirectionBias arg4 ;
76288
76289   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76290   arg2 = (unsigned int)jarg2;
76291   arg3 = (float)jarg3;
76292   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76293   {
76294     try {
76295       (arg1)->ScrollTo(arg2,arg3,arg4);
76296     } catch (std::out_of_range& e) {
76297       {
76298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76299       };
76300     } catch (std::exception& e) {
76301       {
76302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76303       };
76304     } catch (Dali::DaliException e) {
76305       {
76306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76307       };
76308     } catch (...) {
76309       {
76310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76311       };
76312     }
76313   }
76314
76315 }
76316
76317
76318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76319   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76320   Dali::Actor *arg2 = 0 ;
76321
76322   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76323   arg2 = (Dali::Actor *)jarg2;
76324   if (!arg2) {
76325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76326     return ;
76327   }
76328   {
76329     try {
76330       (arg1)->ScrollTo(*arg2);
76331     } catch (std::out_of_range& e) {
76332       {
76333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76334       };
76335     } catch (std::exception& e) {
76336       {
76337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76338       };
76339     } catch (Dali::DaliException e) {
76340       {
76341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76342       };
76343     } catch (...) {
76344       {
76345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76346       };
76347     }
76348   }
76349
76350 }
76351
76352
76353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76354   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76355   Dali::Actor *arg2 = 0 ;
76356   float arg3 ;
76357
76358   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76359   arg2 = (Dali::Actor *)jarg2;
76360   if (!arg2) {
76361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76362     return ;
76363   }
76364   arg3 = (float)jarg3;
76365   {
76366     try {
76367       (arg1)->ScrollTo(*arg2,arg3);
76368     } catch (std::out_of_range& e) {
76369       {
76370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76371       };
76372     } catch (std::exception& e) {
76373       {
76374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76375       };
76376     } catch (Dali::DaliException e) {
76377       {
76378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76379       };
76380     } catch (...) {
76381       {
76382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76383       };
76384     }
76385   }
76386
76387 }
76388
76389
76390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76391   unsigned int jresult ;
76392   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76393   bool result;
76394
76395   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76396   {
76397     try {
76398       result = (bool)(arg1)->ScrollToSnapPoint();
76399     } catch (std::out_of_range& e) {
76400       {
76401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76402       };
76403     } catch (std::exception& e) {
76404       {
76405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76406       };
76407     } catch (Dali::DaliException e) {
76408       {
76409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76410       };
76411     } catch (...) {
76412       {
76413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76414       };
76415     }
76416   }
76417
76418   jresult = result;
76419   return jresult;
76420 }
76421
76422
76423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76424   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76425   Dali::Constraint arg2 ;
76426   Dali::Constraint *argp2 ;
76427
76428   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76429   argp2 = (Dali::Constraint *)jarg2;
76430   if (!argp2) {
76431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76432     return ;
76433   }
76434   arg2 = *argp2;
76435   {
76436     try {
76437       (arg1)->ApplyConstraintToChildren(arg2);
76438     } catch (std::out_of_range& e) {
76439       {
76440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76441       };
76442     } catch (std::exception& e) {
76443       {
76444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76445       };
76446     } catch (Dali::DaliException e) {
76447       {
76448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76449       };
76450     } catch (...) {
76451       {
76452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76453       };
76454     }
76455   }
76456
76457 }
76458
76459
76460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76461   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76462
76463   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76464   {
76465     try {
76466       (arg1)->RemoveConstraintsFromChildren();
76467     } catch (std::out_of_range& e) {
76468       {
76469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76470       };
76471     } catch (std::exception& e) {
76472       {
76473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76474       };
76475     } catch (Dali::DaliException e) {
76476       {
76477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76478       };
76479     } catch (...) {
76480       {
76481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76482       };
76483     }
76484   }
76485
76486 }
76487
76488
76489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76490   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76491   Dali::Toolkit::ScrollViewEffect arg2 ;
76492   Dali::Toolkit::ScrollViewEffect *argp2 ;
76493
76494   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76495   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76496   if (!argp2) {
76497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76498     return ;
76499   }
76500   arg2 = *argp2;
76501   {
76502     try {
76503       (arg1)->ApplyEffect(arg2);
76504     } catch (std::out_of_range& e) {
76505       {
76506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76507       };
76508     } catch (std::exception& e) {
76509       {
76510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76511       };
76512     } catch (Dali::DaliException e) {
76513       {
76514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76515       };
76516     } catch (...) {
76517       {
76518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76519       };
76520     }
76521   }
76522
76523 }
76524
76525
76526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76527   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76528   Dali::Toolkit::ScrollViewEffect arg2 ;
76529   Dali::Toolkit::ScrollViewEffect *argp2 ;
76530
76531   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76532   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76533   if (!argp2) {
76534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76535     return ;
76536   }
76537   arg2 = *argp2;
76538   {
76539     try {
76540       (arg1)->RemoveEffect(arg2);
76541     } catch (std::out_of_range& e) {
76542       {
76543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76544       };
76545     } catch (std::exception& e) {
76546       {
76547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76548       };
76549     } catch (Dali::DaliException e) {
76550       {
76551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76552       };
76553     } catch (...) {
76554       {
76555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76556       };
76557     }
76558   }
76559
76560 }
76561
76562
76563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76564   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76565
76566   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76567   {
76568     try {
76569       (arg1)->RemoveAllEffects();
76570     } catch (std::out_of_range& e) {
76571       {
76572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76573       };
76574     } catch (std::exception& e) {
76575       {
76576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76577       };
76578     } catch (Dali::DaliException e) {
76579       {
76580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76581       };
76582     } catch (...) {
76583       {
76584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76585       };
76586     }
76587   }
76588
76589 }
76590
76591
76592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76594   Dali::Actor arg2 ;
76595   Dali::Actor *argp2 ;
76596
76597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76598   argp2 = (Dali::Actor *)jarg2;
76599   if (!argp2) {
76600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76601     return ;
76602   }
76603   arg2 = *argp2;
76604   {
76605     try {
76606       (arg1)->BindActor(arg2);
76607     } catch (std::out_of_range& e) {
76608       {
76609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76610       };
76611     } catch (std::exception& e) {
76612       {
76613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76614       };
76615     } catch (Dali::DaliException e) {
76616       {
76617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76618       };
76619     } catch (...) {
76620       {
76621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76622       };
76623     }
76624   }
76625
76626 }
76627
76628
76629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76630   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76631   Dali::Actor arg2 ;
76632   Dali::Actor *argp2 ;
76633
76634   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76635   argp2 = (Dali::Actor *)jarg2;
76636   if (!argp2) {
76637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76638     return ;
76639   }
76640   arg2 = *argp2;
76641   {
76642     try {
76643       (arg1)->UnbindActor(arg2);
76644     } catch (std::out_of_range& e) {
76645       {
76646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76647       };
76648     } catch (std::exception& e) {
76649       {
76650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76651       };
76652     } catch (Dali::DaliException e) {
76653       {
76654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76655       };
76656     } catch (...) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76659       };
76660     }
76661   }
76662
76663 }
76664
76665
76666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76668   Dali::Radian arg2 ;
76669   Dali::Radian arg3 ;
76670   Dali::Radian *argp2 ;
76671   Dali::Radian *argp3 ;
76672
76673   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76674   argp2 = (Dali::Radian *)jarg2;
76675   if (!argp2) {
76676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76677     return ;
76678   }
76679   arg2 = *argp2;
76680   argp3 = (Dali::Radian *)jarg3;
76681   if (!argp3) {
76682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76683     return ;
76684   }
76685   arg3 = *argp3;
76686   {
76687     try {
76688       (arg1)->SetScrollingDirection(arg2,arg3);
76689     } catch (std::out_of_range& e) {
76690       {
76691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76692       };
76693     } catch (std::exception& e) {
76694       {
76695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76696       };
76697     } catch (Dali::DaliException e) {
76698       {
76699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76700       };
76701     } catch (...) {
76702       {
76703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76704       };
76705     }
76706   }
76707
76708 }
76709
76710
76711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76712   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76713   Dali::Radian arg2 ;
76714   Dali::Radian *argp2 ;
76715
76716   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76717   argp2 = (Dali::Radian *)jarg2;
76718   if (!argp2) {
76719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76720     return ;
76721   }
76722   arg2 = *argp2;
76723   {
76724     try {
76725       (arg1)->SetScrollingDirection(arg2);
76726     } catch (std::out_of_range& e) {
76727       {
76728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76729       };
76730     } catch (std::exception& e) {
76731       {
76732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76733       };
76734     } catch (Dali::DaliException e) {
76735       {
76736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76737       };
76738     } catch (...) {
76739       {
76740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76741       };
76742     }
76743   }
76744
76745 }
76746
76747
76748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76749   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76750   Dali::Radian arg2 ;
76751   Dali::Radian *argp2 ;
76752
76753   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76754   argp2 = (Dali::Radian *)jarg2;
76755   if (!argp2) {
76756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76757     return ;
76758   }
76759   arg2 = *argp2;
76760   {
76761     try {
76762       (arg1)->RemoveScrollingDirection(arg2);
76763     } catch (std::out_of_range& e) {
76764       {
76765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76766       };
76767     } catch (std::exception& e) {
76768       {
76769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76770       };
76771     } catch (Dali::DaliException e) {
76772       {
76773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76774       };
76775     } catch (...) {
76776       {
76777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76778       };
76779     }
76780   }
76781
76782 }
76783
76784
76785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76786   void * jresult ;
76787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76788   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76789
76790   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76791   {
76792     try {
76793       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76794     } catch (std::out_of_range& e) {
76795       {
76796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76797       };
76798     } catch (std::exception& e) {
76799       {
76800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76801       };
76802     } catch (Dali::DaliException e) {
76803       {
76804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76805       };
76806     } catch (...) {
76807       {
76808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76809       };
76810     }
76811   }
76812
76813   jresult = (void *)result;
76814   return jresult;
76815 }
76816
76817
76818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76819   int jresult ;
76820   int result;
76821
76822   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76823   jresult = (int)result;
76824   return jresult;
76825 }
76826
76827
76828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76829   int jresult ;
76830   int result;
76831
76832   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76833   jresult = (int)result;
76834   return jresult;
76835 }
76836
76837
76838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76839   int jresult ;
76840   int result;
76841
76842   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76843   jresult = (int)result;
76844   return jresult;
76845 }
76846
76847
76848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76849   int jresult ;
76850   int result;
76851
76852   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76853   jresult = (int)result;
76854   return jresult;
76855 }
76856
76857
76858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76859   int jresult ;
76860   int result;
76861
76862   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76863   jresult = (int)result;
76864   return jresult;
76865 }
76866
76867
76868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76869   void * jresult ;
76870   Dali::Toolkit::TableView::Property *result = 0 ;
76871
76872   {
76873     try {
76874       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76875     } catch (std::out_of_range& e) {
76876       {
76877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76878       };
76879     } catch (std::exception& e) {
76880       {
76881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76882       };
76883     } catch (Dali::DaliException e) {
76884       {
76885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76886       };
76887     } catch (...) {
76888       {
76889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76890       };
76891     }
76892   }
76893
76894   jresult = (void *)result;
76895   return jresult;
76896 }
76897
76898
76899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76900   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76901
76902   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76903   {
76904     try {
76905       delete arg1;
76906     } catch (std::out_of_range& e) {
76907       {
76908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76909       };
76910     } catch (std::exception& e) {
76911       {
76912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76913       };
76914     } catch (Dali::DaliException e) {
76915       {
76916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76917       };
76918     } catch (...) {
76919       {
76920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76921       };
76922     }
76923   }
76924
76925 }
76926
76927
76928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76929   int jresult ;
76930   int result;
76931
76932   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76933   jresult = (int)result;
76934   return jresult;
76935 }
76936
76937
76938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76939   int jresult ;
76940   int result;
76941
76942   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76943   jresult = (int)result;
76944   return jresult;
76945 }
76946
76947
76948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76949   int jresult ;
76950   int result;
76951
76952   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76953   jresult = (int)result;
76954   return jresult;
76955 }
76956
76957
76958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76959   int jresult ;
76960   int result;
76961
76962   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76963   jresult = (int)result;
76964   return jresult;
76965 }
76966
76967
76968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76969   int jresult ;
76970   int result;
76971
76972   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76973   jresult = (int)result;
76974   return jresult;
76975 }
76976
76977
76978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76979   void * jresult ;
76980   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76981
76982   {
76983     try {
76984       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76985     } catch (std::out_of_range& e) {
76986       {
76987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76988       };
76989     } catch (std::exception& e) {
76990       {
76991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76992       };
76993     } catch (Dali::DaliException e) {
76994       {
76995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76996       };
76997     } catch (...) {
76998       {
76999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77000       };
77001     }
77002   }
77003
77004   jresult = (void *)result;
77005   return jresult;
77006 }
77007
77008
77009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
77010   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
77011
77012   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
77013   {
77014     try {
77015       delete arg1;
77016     } catch (std::out_of_range& e) {
77017       {
77018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77019       };
77020     } catch (std::exception& e) {
77021       {
77022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77023       };
77024     } catch (Dali::DaliException e) {
77025       {
77026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77027       };
77028     } catch (...) {
77029       {
77030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77031       };
77032     }
77033   }
77034
77035 }
77036
77037
77038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
77039   void * jresult ;
77040   unsigned int arg1 ;
77041   unsigned int arg2 ;
77042   unsigned int arg3 ;
77043   unsigned int arg4 ;
77044   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77045
77046   arg1 = (unsigned int)jarg1;
77047   arg2 = (unsigned int)jarg2;
77048   arg3 = (unsigned int)jarg3;
77049   arg4 = (unsigned int)jarg4;
77050   {
77051     try {
77052       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
77053     } catch (std::out_of_range& e) {
77054       {
77055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77056       };
77057     } catch (std::exception& e) {
77058       {
77059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77060       };
77061     } catch (Dali::DaliException e) {
77062       {
77063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77064       };
77065     } catch (...) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77068       };
77069     }
77070   }
77071
77072   jresult = (void *)result;
77073   return jresult;
77074 }
77075
77076
77077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
77078   void * jresult ;
77079   unsigned int arg1 ;
77080   unsigned int arg2 ;
77081   unsigned int arg3 ;
77082   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77083
77084   arg1 = (unsigned int)jarg1;
77085   arg2 = (unsigned int)jarg2;
77086   arg3 = (unsigned int)jarg3;
77087   {
77088     try {
77089       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
77090     } catch (std::out_of_range& e) {
77091       {
77092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77093       };
77094     } catch (std::exception& e) {
77095       {
77096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77097       };
77098     } catch (Dali::DaliException e) {
77099       {
77100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77101       };
77102     } catch (...) {
77103       {
77104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77105       };
77106     }
77107   }
77108
77109   jresult = (void *)result;
77110   return jresult;
77111 }
77112
77113
77114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
77115   void * jresult ;
77116   unsigned int arg1 ;
77117   unsigned int arg2 ;
77118   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77119
77120   arg1 = (unsigned int)jarg1;
77121   arg2 = (unsigned int)jarg2;
77122   {
77123     try {
77124       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
77125     } catch (std::out_of_range& e) {
77126       {
77127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77128       };
77129     } catch (std::exception& e) {
77130       {
77131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77132       };
77133     } catch (Dali::DaliException e) {
77134       {
77135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77136       };
77137     } catch (...) {
77138       {
77139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77140       };
77141     }
77142   }
77143
77144   jresult = (void *)result;
77145   return jresult;
77146 }
77147
77148
77149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
77150   void * jresult ;
77151   unsigned int arg1 ;
77152   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77153
77154   arg1 = (unsigned int)jarg1;
77155   {
77156     try {
77157       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
77158     } catch (std::out_of_range& e) {
77159       {
77160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77161       };
77162     } catch (std::exception& e) {
77163       {
77164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77165       };
77166     } catch (Dali::DaliException e) {
77167       {
77168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77169       };
77170     } catch (...) {
77171       {
77172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77173       };
77174     }
77175   }
77176
77177   jresult = (void *)result;
77178   return jresult;
77179 }
77180
77181
77182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77183   void * jresult ;
77184   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77185
77186   {
77187     try {
77188       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77189     } catch (std::out_of_range& e) {
77190       {
77191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77192       };
77193     } catch (std::exception& e) {
77194       {
77195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77196       };
77197     } catch (Dali::DaliException e) {
77198       {
77199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77200       };
77201     } catch (...) {
77202       {
77203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77204       };
77205     }
77206   }
77207
77208   jresult = (void *)result;
77209   return jresult;
77210 }
77211
77212
77213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77214   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77215   unsigned int arg2 ;
77216
77217   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77218   arg2 = (unsigned int)jarg2;
77219   if (arg1) (arg1)->rowIndex = arg2;
77220 }
77221
77222
77223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77224   unsigned int jresult ;
77225   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77226   unsigned int result;
77227
77228   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77229   result = (unsigned int) ((arg1)->rowIndex);
77230   jresult = result;
77231   return jresult;
77232 }
77233
77234
77235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77236   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77237   unsigned int arg2 ;
77238
77239   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77240   arg2 = (unsigned int)jarg2;
77241   if (arg1) (arg1)->columnIndex = arg2;
77242 }
77243
77244
77245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77246   unsigned int jresult ;
77247   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77248   unsigned int result;
77249
77250   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77251   result = (unsigned int) ((arg1)->columnIndex);
77252   jresult = result;
77253   return jresult;
77254 }
77255
77256
77257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77258   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77259   unsigned int arg2 ;
77260
77261   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77262   arg2 = (unsigned int)jarg2;
77263   if (arg1) (arg1)->rowSpan = arg2;
77264 }
77265
77266
77267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77268   unsigned int jresult ;
77269   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77270   unsigned int result;
77271
77272   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77273   result = (unsigned int) ((arg1)->rowSpan);
77274   jresult = result;
77275   return jresult;
77276 }
77277
77278
77279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77280   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77281   unsigned int arg2 ;
77282
77283   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77284   arg2 = (unsigned int)jarg2;
77285   if (arg1) (arg1)->columnSpan = arg2;
77286 }
77287
77288
77289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77290   unsigned int jresult ;
77291   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77292   unsigned int result;
77293
77294   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77295   result = (unsigned int) ((arg1)->columnSpan);
77296   jresult = result;
77297   return jresult;
77298 }
77299
77300
77301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77302   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77303
77304   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77305   {
77306     try {
77307       delete arg1;
77308     } catch (std::out_of_range& e) {
77309       {
77310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77311       };
77312     } catch (std::exception& e) {
77313       {
77314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77315       };
77316     } catch (Dali::DaliException e) {
77317       {
77318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77319       };
77320     } catch (...) {
77321       {
77322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77323       };
77324     }
77325   }
77326
77327 }
77328
77329
77330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77331   void * jresult ;
77332   Dali::Toolkit::TableView *result = 0 ;
77333
77334   {
77335     try {
77336       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77337     } catch (std::out_of_range& e) {
77338       {
77339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77340       };
77341     } catch (std::exception& e) {
77342       {
77343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77344       };
77345     } catch (Dali::DaliException e) {
77346       {
77347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77348       };
77349     } catch (...) {
77350       {
77351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77352       };
77353     }
77354   }
77355
77356   jresult = (void *)result;
77357   return jresult;
77358 }
77359
77360
77361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77362   void * jresult ;
77363   Dali::Toolkit::TableView *arg1 = 0 ;
77364   Dali::Toolkit::TableView *result = 0 ;
77365
77366   arg1 = (Dali::Toolkit::TableView *)jarg1;
77367   if (!arg1) {
77368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77369     return 0;
77370   }
77371   {
77372     try {
77373       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77374     } catch (std::out_of_range& e) {
77375       {
77376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77377       };
77378     } catch (std::exception& e) {
77379       {
77380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77381       };
77382     } catch (Dali::DaliException e) {
77383       {
77384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77385       };
77386     } catch (...) {
77387       {
77388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77389       };
77390     }
77391   }
77392
77393   jresult = (void *)result;
77394   return jresult;
77395 }
77396
77397
77398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77399   void * jresult ;
77400   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77401   Dali::Toolkit::TableView *arg2 = 0 ;
77402   Dali::Toolkit::TableView *result = 0 ;
77403
77404   arg1 = (Dali::Toolkit::TableView *)jarg1;
77405   arg2 = (Dali::Toolkit::TableView *)jarg2;
77406   if (!arg2) {
77407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77408     return 0;
77409   }
77410   {
77411     try {
77412       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77413     } catch (std::out_of_range& e) {
77414       {
77415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77416       };
77417     } catch (std::exception& e) {
77418       {
77419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77420       };
77421     } catch (Dali::DaliException e) {
77422       {
77423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77424       };
77425     } catch (...) {
77426       {
77427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77428       };
77429     }
77430   }
77431
77432   jresult = (void *)result;
77433   return jresult;
77434 }
77435
77436
77437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77438   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77439
77440   arg1 = (Dali::Toolkit::TableView *)jarg1;
77441   {
77442     try {
77443       delete arg1;
77444     } catch (std::out_of_range& e) {
77445       {
77446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77447       };
77448     } catch (std::exception& e) {
77449       {
77450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77451       };
77452     } catch (Dali::DaliException e) {
77453       {
77454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77455       };
77456     } catch (...) {
77457       {
77458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77459       };
77460     }
77461   }
77462
77463 }
77464
77465
77466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77467   void * jresult ;
77468   unsigned int arg1 ;
77469   unsigned int arg2 ;
77470   Dali::Toolkit::TableView result;
77471
77472   arg1 = (unsigned int)jarg1;
77473   arg2 = (unsigned int)jarg2;
77474   {
77475     try {
77476       result = Dali::Toolkit::TableView::New(arg1,arg2);
77477     } catch (std::out_of_range& e) {
77478       {
77479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77480       };
77481     } catch (std::exception& e) {
77482       {
77483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77484       };
77485     } catch (Dali::DaliException e) {
77486       {
77487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77488       };
77489     } catch (...) {
77490       {
77491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77492       };
77493     }
77494   }
77495
77496   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77497   return jresult;
77498 }
77499
77500
77501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77502   void * jresult ;
77503   Dali::BaseHandle arg1 ;
77504   Dali::BaseHandle *argp1 ;
77505   Dali::Toolkit::TableView result;
77506
77507   argp1 = (Dali::BaseHandle *)jarg1;
77508   if (!argp1) {
77509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77510     return 0;
77511   }
77512   arg1 = *argp1;
77513   {
77514     try {
77515       result = Dali::Toolkit::TableView::DownCast(arg1);
77516     } catch (std::out_of_range& e) {
77517       {
77518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77519       };
77520     } catch (std::exception& e) {
77521       {
77522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77523       };
77524     } catch (Dali::DaliException e) {
77525       {
77526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77527       };
77528     } catch (...) {
77529       {
77530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77531       };
77532     }
77533   }
77534
77535   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77536   return jresult;
77537 }
77538
77539
77540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77541   unsigned int jresult ;
77542   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77543   Dali::Actor arg2 ;
77544   Dali::Toolkit::TableView::CellPosition arg3 ;
77545   Dali::Actor *argp2 ;
77546   Dali::Toolkit::TableView::CellPosition *argp3 ;
77547   bool result;
77548
77549   arg1 = (Dali::Toolkit::TableView *)jarg1;
77550   argp2 = (Dali::Actor *)jarg2;
77551   if (!argp2) {
77552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77553     return 0;
77554   }
77555   arg2 = *argp2;
77556   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77557   if (!argp3) {
77558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77559     return 0;
77560   }
77561   arg3 = *argp3;
77562   {
77563     try {
77564       result = (bool)(arg1)->AddChild(arg2,arg3);
77565     } catch (std::out_of_range& e) {
77566       {
77567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77568       };
77569     } catch (std::exception& e) {
77570       {
77571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77572       };
77573     } catch (Dali::DaliException e) {
77574       {
77575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77576       };
77577     } catch (...) {
77578       {
77579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77580       };
77581     }
77582   }
77583
77584   jresult = result;
77585   return jresult;
77586 }
77587
77588
77589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77590   void * jresult ;
77591   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77592   Dali::Toolkit::TableView::CellPosition arg2 ;
77593   Dali::Toolkit::TableView::CellPosition *argp2 ;
77594   Dali::Actor result;
77595
77596   arg1 = (Dali::Toolkit::TableView *)jarg1;
77597   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77598   if (!argp2) {
77599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77600     return 0;
77601   }
77602   arg2 = *argp2;
77603   {
77604     try {
77605       result = (arg1)->GetChildAt(arg2);
77606     } catch (std::out_of_range& e) {
77607       {
77608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77609       };
77610     } catch (std::exception& e) {
77611       {
77612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77613       };
77614     } catch (Dali::DaliException e) {
77615       {
77616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77617       };
77618     } catch (...) {
77619       {
77620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77621       };
77622     }
77623   }
77624
77625   jresult = new Dali::Actor((const Dali::Actor &)result);
77626   return jresult;
77627 }
77628
77629
77630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77631   void * jresult ;
77632   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77633   Dali::Toolkit::TableView::CellPosition arg2 ;
77634   Dali::Toolkit::TableView::CellPosition *argp2 ;
77635   Dali::Actor result;
77636
77637   arg1 = (Dali::Toolkit::TableView *)jarg1;
77638   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77639   if (!argp2) {
77640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77641     return 0;
77642   }
77643   arg2 = *argp2;
77644   {
77645     try {
77646       result = (arg1)->RemoveChildAt(arg2);
77647     } catch (std::out_of_range& e) {
77648       {
77649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77650       };
77651     } catch (std::exception& e) {
77652       {
77653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77654       };
77655     } catch (Dali::DaliException e) {
77656       {
77657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77658       };
77659     } catch (...) {
77660       {
77661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77662       };
77663     }
77664   }
77665
77666   jresult = new Dali::Actor((const Dali::Actor &)result);
77667   return jresult;
77668 }
77669
77670
77671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77672   unsigned int jresult ;
77673   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77674   Dali::Actor arg2 ;
77675   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77676   Dali::Actor *argp2 ;
77677   bool result;
77678
77679   arg1 = (Dali::Toolkit::TableView *)jarg1;
77680   argp2 = (Dali::Actor *)jarg2;
77681   if (!argp2) {
77682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77683     return 0;
77684   }
77685   arg2 = *argp2;
77686   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77687   if (!arg3) {
77688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77689     return 0;
77690   }
77691   {
77692     try {
77693       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77694     } catch (std::out_of_range& e) {
77695       {
77696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77697       };
77698     } catch (std::exception& e) {
77699       {
77700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77701       };
77702     } catch (Dali::DaliException e) {
77703       {
77704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77705       };
77706     } catch (...) {
77707       {
77708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77709       };
77710     }
77711   }
77712
77713   jresult = result;
77714   return jresult;
77715 }
77716
77717
77718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77719   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77720   unsigned int arg2 ;
77721
77722   arg1 = (Dali::Toolkit::TableView *)jarg1;
77723   arg2 = (unsigned int)jarg2;
77724   {
77725     try {
77726       (arg1)->InsertRow(arg2);
77727     } catch (std::out_of_range& e) {
77728       {
77729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77730       };
77731     } catch (std::exception& e) {
77732       {
77733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77734       };
77735     } catch (Dali::DaliException e) {
77736       {
77737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77738       };
77739     } catch (...) {
77740       {
77741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77742       };
77743     }
77744   }
77745
77746 }
77747
77748
77749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77750   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77751   unsigned int arg2 ;
77752
77753   arg1 = (Dali::Toolkit::TableView *)jarg1;
77754   arg2 = (unsigned int)jarg2;
77755   {
77756     try {
77757       (arg1)->DeleteRow(arg2);
77758     } catch (std::out_of_range& e) {
77759       {
77760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77761       };
77762     } catch (std::exception& e) {
77763       {
77764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77765       };
77766     } catch (Dali::DaliException e) {
77767       {
77768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77769       };
77770     } catch (...) {
77771       {
77772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77773       };
77774     }
77775   }
77776
77777 }
77778
77779
77780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77781   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77782   unsigned int arg2 ;
77783   std::vector< Dali::Actor > *arg3 = 0 ;
77784
77785   arg1 = (Dali::Toolkit::TableView *)jarg1;
77786   arg2 = (unsigned int)jarg2;
77787   arg3 = (std::vector< Dali::Actor > *)jarg3;
77788   if (!arg3) {
77789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77790     return ;
77791   }
77792   {
77793     try {
77794       (arg1)->DeleteRow(arg2,*arg3);
77795     } catch (std::out_of_range& e) {
77796       {
77797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77798       };
77799     } catch (std::exception& e) {
77800       {
77801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77802       };
77803     } catch (Dali::DaliException e) {
77804       {
77805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77806       };
77807     } catch (...) {
77808       {
77809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77810       };
77811     }
77812   }
77813
77814 }
77815
77816
77817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77818   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77819   unsigned int arg2 ;
77820
77821   arg1 = (Dali::Toolkit::TableView *)jarg1;
77822   arg2 = (unsigned int)jarg2;
77823   {
77824     try {
77825       (arg1)->InsertColumn(arg2);
77826     } catch (std::out_of_range& e) {
77827       {
77828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77829       };
77830     } catch (std::exception& e) {
77831       {
77832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77833       };
77834     } catch (Dali::DaliException e) {
77835       {
77836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77837       };
77838     } catch (...) {
77839       {
77840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77841       };
77842     }
77843   }
77844
77845 }
77846
77847
77848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77849   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77850   unsigned int arg2 ;
77851
77852   arg1 = (Dali::Toolkit::TableView *)jarg1;
77853   arg2 = (unsigned int)jarg2;
77854   {
77855     try {
77856       (arg1)->DeleteColumn(arg2);
77857     } catch (std::out_of_range& e) {
77858       {
77859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77860       };
77861     } catch (std::exception& e) {
77862       {
77863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77864       };
77865     } catch (Dali::DaliException e) {
77866       {
77867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77868       };
77869     } catch (...) {
77870       {
77871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77872       };
77873     }
77874   }
77875
77876 }
77877
77878
77879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77880   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77881   unsigned int arg2 ;
77882   std::vector< Dali::Actor > *arg3 = 0 ;
77883
77884   arg1 = (Dali::Toolkit::TableView *)jarg1;
77885   arg2 = (unsigned int)jarg2;
77886   arg3 = (std::vector< Dali::Actor > *)jarg3;
77887   if (!arg3) {
77888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77889     return ;
77890   }
77891   {
77892     try {
77893       (arg1)->DeleteColumn(arg2,*arg3);
77894     } catch (std::out_of_range& e) {
77895       {
77896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77897       };
77898     } catch (std::exception& e) {
77899       {
77900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77901       };
77902     } catch (Dali::DaliException e) {
77903       {
77904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77905       };
77906     } catch (...) {
77907       {
77908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77909       };
77910     }
77911   }
77912
77913 }
77914
77915
77916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77917   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77918   unsigned int arg2 ;
77919   unsigned int arg3 ;
77920
77921   arg1 = (Dali::Toolkit::TableView *)jarg1;
77922   arg2 = (unsigned int)jarg2;
77923   arg3 = (unsigned int)jarg3;
77924   {
77925     try {
77926       (arg1)->Resize(arg2,arg3);
77927     } catch (std::out_of_range& e) {
77928       {
77929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77930       };
77931     } catch (std::exception& e) {
77932       {
77933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77934       };
77935     } catch (Dali::DaliException e) {
77936       {
77937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77938       };
77939     } catch (...) {
77940       {
77941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77942       };
77943     }
77944   }
77945
77946 }
77947
77948
77949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77950   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77951   unsigned int arg2 ;
77952   unsigned int arg3 ;
77953   std::vector< Dali::Actor > *arg4 = 0 ;
77954
77955   arg1 = (Dali::Toolkit::TableView *)jarg1;
77956   arg2 = (unsigned int)jarg2;
77957   arg3 = (unsigned int)jarg3;
77958   arg4 = (std::vector< Dali::Actor > *)jarg4;
77959   if (!arg4) {
77960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77961     return ;
77962   }
77963   {
77964     try {
77965       (arg1)->Resize(arg2,arg3,*arg4);
77966     } catch (std::out_of_range& e) {
77967       {
77968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77969       };
77970     } catch (std::exception& e) {
77971       {
77972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77973       };
77974     } catch (Dali::DaliException e) {
77975       {
77976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77977       };
77978     } catch (...) {
77979       {
77980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77981       };
77982     }
77983   }
77984
77985 }
77986
77987
77988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77989   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77990   Dali::Size arg2 ;
77991   Dali::Size *argp2 ;
77992
77993   arg1 = (Dali::Toolkit::TableView *)jarg1;
77994   argp2 = (Dali::Size *)jarg2;
77995   if (!argp2) {
77996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77997     return ;
77998   }
77999   arg2 = *argp2;
78000   {
78001     try {
78002       (arg1)->SetCellPadding(arg2);
78003     } catch (std::out_of_range& e) {
78004       {
78005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78006       };
78007     } catch (std::exception& e) {
78008       {
78009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78010       };
78011     } catch (Dali::DaliException e) {
78012       {
78013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78014       };
78015     } catch (...) {
78016       {
78017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78018       };
78019     }
78020   }
78021
78022 }
78023
78024
78025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
78026   void * jresult ;
78027   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78028   Dali::Size result;
78029
78030   arg1 = (Dali::Toolkit::TableView *)jarg1;
78031   {
78032     try {
78033       result = (arg1)->GetCellPadding();
78034     } catch (std::out_of_range& e) {
78035       {
78036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78037       };
78038     } catch (std::exception& e) {
78039       {
78040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78041       };
78042     } catch (Dali::DaliException e) {
78043       {
78044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78045       };
78046     } catch (...) {
78047       {
78048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78049       };
78050     }
78051   }
78052
78053   jresult = new Dali::Size((const Dali::Size &)result);
78054   return jresult;
78055 }
78056
78057
78058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
78059   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78060   unsigned int arg2 ;
78061
78062   arg1 = (Dali::Toolkit::TableView *)jarg1;
78063   arg2 = (unsigned int)jarg2;
78064   {
78065     try {
78066       (arg1)->SetFitHeight(arg2);
78067     } catch (std::out_of_range& e) {
78068       {
78069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78070       };
78071     } catch (std::exception& e) {
78072       {
78073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78074       };
78075     } catch (Dali::DaliException e) {
78076       {
78077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78078       };
78079     } catch (...) {
78080       {
78081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78082       };
78083     }
78084   }
78085
78086 }
78087
78088
78089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
78090   unsigned int jresult ;
78091   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78092   unsigned int arg2 ;
78093   bool result;
78094
78095   arg1 = (Dali::Toolkit::TableView *)jarg1;
78096   arg2 = (unsigned int)jarg2;
78097   {
78098     try {
78099       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
78100     } catch (std::out_of_range& e) {
78101       {
78102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78103       };
78104     } catch (std::exception& e) {
78105       {
78106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78107       };
78108     } catch (Dali::DaliException e) {
78109       {
78110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78111       };
78112     } catch (...) {
78113       {
78114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78115       };
78116     }
78117   }
78118
78119   jresult = result;
78120   return jresult;
78121 }
78122
78123
78124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
78125   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78126   unsigned int arg2 ;
78127
78128   arg1 = (Dali::Toolkit::TableView *)jarg1;
78129   arg2 = (unsigned int)jarg2;
78130   {
78131     try {
78132       (arg1)->SetFitWidth(arg2);
78133     } catch (std::out_of_range& e) {
78134       {
78135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78136       };
78137     } catch (std::exception& e) {
78138       {
78139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78140       };
78141     } catch (Dali::DaliException e) {
78142       {
78143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78144       };
78145     } catch (...) {
78146       {
78147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78148       };
78149     }
78150   }
78151
78152 }
78153
78154
78155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
78156   unsigned int jresult ;
78157   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78158   unsigned int arg2 ;
78159   bool result;
78160
78161   arg1 = (Dali::Toolkit::TableView *)jarg1;
78162   arg2 = (unsigned int)jarg2;
78163   {
78164     try {
78165       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
78166     } catch (std::out_of_range& e) {
78167       {
78168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78169       };
78170     } catch (std::exception& e) {
78171       {
78172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78173       };
78174     } catch (Dali::DaliException e) {
78175       {
78176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78177       };
78178     } catch (...) {
78179       {
78180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78181       };
78182     }
78183   }
78184
78185   jresult = result;
78186   return jresult;
78187 }
78188
78189
78190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78191   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78192   unsigned int arg2 ;
78193   float arg3 ;
78194
78195   arg1 = (Dali::Toolkit::TableView *)jarg1;
78196   arg2 = (unsigned int)jarg2;
78197   arg3 = (float)jarg3;
78198   {
78199     try {
78200       (arg1)->SetFixedHeight(arg2,arg3);
78201     } catch (std::out_of_range& e) {
78202       {
78203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78204       };
78205     } catch (std::exception& e) {
78206       {
78207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78208       };
78209     } catch (Dali::DaliException e) {
78210       {
78211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78212       };
78213     } catch (...) {
78214       {
78215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78216       };
78217     }
78218   }
78219
78220 }
78221
78222
78223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78224   float jresult ;
78225   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78226   unsigned int arg2 ;
78227   float result;
78228
78229   arg1 = (Dali::Toolkit::TableView *)jarg1;
78230   arg2 = (unsigned int)jarg2;
78231   {
78232     try {
78233       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78234     } catch (std::out_of_range& e) {
78235       {
78236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78237       };
78238     } catch (std::exception& e) {
78239       {
78240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78241       };
78242     } catch (Dali::DaliException e) {
78243       {
78244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78245       };
78246     } catch (...) {
78247       {
78248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78249       };
78250     }
78251   }
78252
78253   jresult = result;
78254   return jresult;
78255 }
78256
78257
78258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78259   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78260   unsigned int arg2 ;
78261   float arg3 ;
78262
78263   arg1 = (Dali::Toolkit::TableView *)jarg1;
78264   arg2 = (unsigned int)jarg2;
78265   arg3 = (float)jarg3;
78266   {
78267     try {
78268       (arg1)->SetRelativeHeight(arg2,arg3);
78269     } catch (std::out_of_range& e) {
78270       {
78271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78272       };
78273     } catch (std::exception& e) {
78274       {
78275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78276       };
78277     } catch (Dali::DaliException e) {
78278       {
78279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78280       };
78281     } catch (...) {
78282       {
78283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78284       };
78285     }
78286   }
78287
78288 }
78289
78290
78291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78292   float jresult ;
78293   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78294   unsigned int arg2 ;
78295   float result;
78296
78297   arg1 = (Dali::Toolkit::TableView *)jarg1;
78298   arg2 = (unsigned int)jarg2;
78299   {
78300     try {
78301       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78302     } catch (std::out_of_range& e) {
78303       {
78304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78305       };
78306     } catch (std::exception& e) {
78307       {
78308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78309       };
78310     } catch (Dali::DaliException e) {
78311       {
78312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78313       };
78314     } catch (...) {
78315       {
78316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78317       };
78318     }
78319   }
78320
78321   jresult = result;
78322   return jresult;
78323 }
78324
78325
78326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78327   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78328   unsigned int arg2 ;
78329   float arg3 ;
78330
78331   arg1 = (Dali::Toolkit::TableView *)jarg1;
78332   arg2 = (unsigned int)jarg2;
78333   arg3 = (float)jarg3;
78334   {
78335     try {
78336       (arg1)->SetFixedWidth(arg2,arg3);
78337     } catch (std::out_of_range& e) {
78338       {
78339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78340       };
78341     } catch (std::exception& e) {
78342       {
78343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78344       };
78345     } catch (Dali::DaliException e) {
78346       {
78347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78348       };
78349     } catch (...) {
78350       {
78351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78352       };
78353     }
78354   }
78355
78356 }
78357
78358
78359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78360   float jresult ;
78361   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78362   unsigned int arg2 ;
78363   float result;
78364
78365   arg1 = (Dali::Toolkit::TableView *)jarg1;
78366   arg2 = (unsigned int)jarg2;
78367   {
78368     try {
78369       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78370     } catch (std::out_of_range& e) {
78371       {
78372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78373       };
78374     } catch (std::exception& e) {
78375       {
78376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78377       };
78378     } catch (Dali::DaliException e) {
78379       {
78380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78381       };
78382     } catch (...) {
78383       {
78384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78385       };
78386     }
78387   }
78388
78389   jresult = result;
78390   return jresult;
78391 }
78392
78393
78394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78395   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78396   unsigned int arg2 ;
78397   float arg3 ;
78398
78399   arg1 = (Dali::Toolkit::TableView *)jarg1;
78400   arg2 = (unsigned int)jarg2;
78401   arg3 = (float)jarg3;
78402   {
78403     try {
78404       (arg1)->SetRelativeWidth(arg2,arg3);
78405     } catch (std::out_of_range& e) {
78406       {
78407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78408       };
78409     } catch (std::exception& e) {
78410       {
78411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78412       };
78413     } catch (Dali::DaliException e) {
78414       {
78415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78416       };
78417     } catch (...) {
78418       {
78419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78420       };
78421     }
78422   }
78423
78424 }
78425
78426
78427 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78428   float jresult ;
78429   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78430   unsigned int arg2 ;
78431   float result;
78432
78433   arg1 = (Dali::Toolkit::TableView *)jarg1;
78434   arg2 = (unsigned int)jarg2;
78435   {
78436     try {
78437       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78438     } catch (std::out_of_range& e) {
78439       {
78440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78441       };
78442     } catch (std::exception& e) {
78443       {
78444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78445       };
78446     } catch (Dali::DaliException e) {
78447       {
78448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78449       };
78450     } catch (...) {
78451       {
78452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78453       };
78454     }
78455   }
78456
78457   jresult = result;
78458   return jresult;
78459 }
78460
78461
78462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78463   unsigned int jresult ;
78464   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78465   unsigned int result;
78466
78467   arg1 = (Dali::Toolkit::TableView *)jarg1;
78468   {
78469     try {
78470       result = (unsigned int)(arg1)->GetRows();
78471     } catch (std::out_of_range& e) {
78472       {
78473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78474       };
78475     } catch (std::exception& e) {
78476       {
78477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78478       };
78479     } catch (Dali::DaliException e) {
78480       {
78481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78482       };
78483     } catch (...) {
78484       {
78485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78486       };
78487     }
78488   }
78489
78490   jresult = result;
78491   return jresult;
78492 }
78493
78494
78495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78496   unsigned int jresult ;
78497   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78498   unsigned int result;
78499
78500   arg1 = (Dali::Toolkit::TableView *)jarg1;
78501   {
78502     try {
78503       result = (unsigned int)(arg1)->GetColumns();
78504     } catch (std::out_of_range& e) {
78505       {
78506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78507       };
78508     } catch (std::exception& e) {
78509       {
78510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78511       };
78512     } catch (Dali::DaliException e) {
78513       {
78514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78515       };
78516     } catch (...) {
78517       {
78518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78519       };
78520     }
78521   }
78522
78523   jresult = result;
78524   return jresult;
78525 }
78526
78527
78528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78529   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78530   Dali::Toolkit::TableView::CellPosition arg2 ;
78531   Dali::HorizontalAlignment::Type arg3 ;
78532   Dali::VerticalAlignment::Type arg4 ;
78533   Dali::Toolkit::TableView::CellPosition *argp2 ;
78534
78535   arg1 = (Dali::Toolkit::TableView *)jarg1;
78536   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78537   if (!argp2) {
78538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78539     return ;
78540   }
78541   arg2 = *argp2;
78542   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78543   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78544   {
78545     try {
78546       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78547     } catch (std::out_of_range& e) {
78548       {
78549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78550       };
78551     } catch (std::exception& e) {
78552       {
78553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78554       };
78555     } catch (Dali::DaliException e) {
78556       {
78557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78558       };
78559     } catch (...) {
78560       {
78561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78562       };
78563     }
78564   }
78565
78566 }
78567
78568
78569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78570   unsigned int jresult ;
78571   unsigned int result;
78572
78573   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78574   jresult = result;
78575   return jresult;
78576 }
78577
78578
78579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78580   int jresult ;
78581   int result;
78582
78583   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78584   jresult = (int)result;
78585   return jresult;
78586 }
78587
78588
78589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78590   int jresult ;
78591   int result;
78592
78593   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78594   jresult = (int)result;
78595   return jresult;
78596 }
78597
78598
78599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78600   int jresult ;
78601   int result;
78602
78603   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78604   jresult = (int)result;
78605   return jresult;
78606 }
78607
78608
78609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78610   int jresult ;
78611   int result;
78612
78613   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78614   jresult = (int)result;
78615   return jresult;
78616 }
78617
78618
78619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78620   int jresult ;
78621   int result;
78622
78623   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78624   jresult = (int)result;
78625   return jresult;
78626 }
78627
78628
78629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78630   int jresult ;
78631   int result;
78632
78633   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78634   jresult = (int)result;
78635   return jresult;
78636 }
78637
78638
78639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78640   int jresult ;
78641   int result;
78642
78643   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78644   jresult = (int)result;
78645   return jresult;
78646 }
78647
78648
78649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78650   int jresult ;
78651   int result;
78652
78653   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78654   jresult = (int)result;
78655   return jresult;
78656 }
78657
78658
78659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78660   int jresult ;
78661   int result;
78662
78663   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78664   jresult = (int)result;
78665   return jresult;
78666 }
78667
78668
78669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78670   int jresult ;
78671   int result;
78672
78673   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78674   jresult = (int)result;
78675   return jresult;
78676 }
78677
78678
78679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78680   int jresult ;
78681   int result;
78682
78683   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78684   jresult = (int)result;
78685   return jresult;
78686 }
78687
78688
78689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78690   int jresult ;
78691   int result;
78692
78693   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78694   jresult = (int)result;
78695   return jresult;
78696 }
78697
78698
78699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78700   int jresult ;
78701   int result;
78702
78703   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78704   jresult = (int)result;
78705   return jresult;
78706 }
78707
78708
78709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78710   int jresult ;
78711   int result;
78712
78713   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78714   jresult = (int)result;
78715   return jresult;
78716 }
78717
78718
78719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78720   int jresult ;
78721   int result;
78722
78723   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78724   jresult = (int)result;
78725   return jresult;
78726 }
78727
78728
78729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78730   int jresult ;
78731   int result;
78732
78733   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78734   jresult = (int)result;
78735   return jresult;
78736 }
78737
78738
78739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78740   int jresult ;
78741   int result;
78742
78743   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78744   jresult = (int)result;
78745   return jresult;
78746 }
78747
78748
78749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78750   int jresult ;
78751   int result;
78752
78753   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78754   jresult = (int)result;
78755   return jresult;
78756 }
78757
78758
78759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78760   void * jresult ;
78761   Dali::Toolkit::TextLabel::Property *result = 0 ;
78762
78763   {
78764     try {
78765       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78766     } catch (std::out_of_range& e) {
78767       {
78768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78769       };
78770     } catch (std::exception& e) {
78771       {
78772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78773       };
78774     } catch (Dali::DaliException e) {
78775       {
78776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78777       };
78778     } catch (...) {
78779       {
78780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78781       };
78782     }
78783   }
78784
78785   jresult = (void *)result;
78786   return jresult;
78787 }
78788
78789
78790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78791   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78792
78793   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78794   {
78795     try {
78796       delete arg1;
78797     } catch (std::out_of_range& e) {
78798       {
78799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78800       };
78801     } catch (std::exception& e) {
78802       {
78803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78804       };
78805     } catch (Dali::DaliException e) {
78806       {
78807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78808       };
78809     } catch (...) {
78810       {
78811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78812       };
78813     }
78814   }
78815
78816 }
78817
78818
78819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78820   void * jresult ;
78821   Dali::Toolkit::TextLabel result;
78822
78823   {
78824     try {
78825       result = Dali::Toolkit::TextLabel::New();
78826     } catch (std::out_of_range& e) {
78827       {
78828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78829       };
78830     } catch (std::exception& e) {
78831       {
78832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78833       };
78834     } catch (Dali::DaliException e) {
78835       {
78836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78837       };
78838     } catch (...) {
78839       {
78840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78841       };
78842     }
78843   }
78844
78845   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78846   return jresult;
78847 }
78848
78849
78850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78851   void * jresult ;
78852   std::string *arg1 = 0 ;
78853   Dali::Toolkit::TextLabel result;
78854
78855   if (!jarg1) {
78856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78857     return 0;
78858   }
78859   std::string arg1_str(jarg1);
78860   arg1 = &arg1_str;
78861   {
78862     try {
78863       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
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 = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78884
78885   //argout typemap for const std::string&
78886
78887   return jresult;
78888 }
78889
78890
78891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78892   void * jresult ;
78893   Dali::Toolkit::TextLabel *result = 0 ;
78894
78895   {
78896     try {
78897       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78898     } catch (std::out_of_range& e) {
78899       {
78900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78901       };
78902     } catch (std::exception& e) {
78903       {
78904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78905       };
78906     } catch (Dali::DaliException e) {
78907       {
78908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78909       };
78910     } catch (...) {
78911       {
78912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78913       };
78914     }
78915   }
78916
78917   jresult = (void *)result;
78918   return jresult;
78919 }
78920
78921
78922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78923   void * jresult ;
78924   Dali::Toolkit::TextLabel *arg1 = 0 ;
78925   Dali::Toolkit::TextLabel *result = 0 ;
78926
78927   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78928   if (!arg1) {
78929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78930     return 0;
78931   }
78932   {
78933     try {
78934       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78935     } catch (std::out_of_range& e) {
78936       {
78937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78938       };
78939     } catch (std::exception& e) {
78940       {
78941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78942       };
78943     } catch (Dali::DaliException e) {
78944       {
78945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78946       };
78947     } catch (...) {
78948       {
78949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78950       };
78951     }
78952   }
78953
78954   jresult = (void *)result;
78955   return jresult;
78956 }
78957
78958
78959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78960   void * jresult ;
78961   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78962   Dali::Toolkit::TextLabel *arg2 = 0 ;
78963   Dali::Toolkit::TextLabel *result = 0 ;
78964
78965   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78966   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78967   if (!arg2) {
78968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78969     return 0;
78970   }
78971   {
78972     try {
78973       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78974     } catch (std::out_of_range& e) {
78975       {
78976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78977       };
78978     } catch (std::exception& e) {
78979       {
78980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78981       };
78982     } catch (Dali::DaliException e) {
78983       {
78984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78985       };
78986     } catch (...) {
78987       {
78988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78989       };
78990     }
78991   }
78992
78993   jresult = (void *)result;
78994   return jresult;
78995 }
78996
78997
78998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78999   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79000
79001   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79002   {
79003     try {
79004       delete arg1;
79005     } catch (std::out_of_range& e) {
79006       {
79007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79008       };
79009     } catch (std::exception& e) {
79010       {
79011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79012       };
79013     } catch (Dali::DaliException e) {
79014       {
79015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79016       };
79017     } catch (...) {
79018       {
79019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79020       };
79021     }
79022   }
79023
79024 }
79025
79026
79027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79028   void * jresult ;
79029   Dali::BaseHandle arg1 ;
79030   Dali::BaseHandle *argp1 ;
79031   Dali::Toolkit::TextLabel result;
79032
79033   argp1 = (Dali::BaseHandle *)jarg1;
79034   if (!argp1) {
79035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79036     return 0;
79037   }
79038   arg1 = *argp1;
79039   {
79040     try {
79041       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79042     } catch (std::out_of_range& e) {
79043       {
79044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79045       };
79046     } catch (std::exception& e) {
79047       {
79048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79049       };
79050     } catch (Dali::DaliException e) {
79051       {
79052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79053       };
79054     } catch (...) {
79055       {
79056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79057       };
79058     }
79059   }
79060
79061   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79062   return jresult;
79063 }
79064
79065
79066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79067   void * jresult ;
79068   Dali::Toolkit::AccessibilityManager *result = 0 ;
79069
79070   {
79071     try {
79072       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79073     } catch (std::out_of_range& e) {
79074       {
79075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79076       };
79077     } catch (std::exception& e) {
79078       {
79079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79080       };
79081     } catch (Dali::DaliException e) {
79082       {
79083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79084       };
79085     } catch (...) {
79086       {
79087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79088       };
79089     }
79090   }
79091
79092   jresult = (void *)result;
79093   return jresult;
79094 }
79095
79096
79097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79098   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79099
79100   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79101   {
79102     try {
79103       delete arg1;
79104     } catch (std::out_of_range& e) {
79105       {
79106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79107       };
79108     } catch (std::exception& e) {
79109       {
79110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79111       };
79112     } catch (Dali::DaliException e) {
79113       {
79114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79115       };
79116     } catch (...) {
79117       {
79118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79119       };
79120     }
79121   }
79122
79123 }
79124
79125
79126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79127   void * jresult ;
79128   Dali::Toolkit::AccessibilityManager result;
79129
79130   {
79131     try {
79132       result = Dali::Toolkit::AccessibilityManager::Get();
79133     } catch (std::out_of_range& e) {
79134       {
79135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79136       };
79137     } catch (std::exception& e) {
79138       {
79139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79140       };
79141     } catch (Dali::DaliException e) {
79142       {
79143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79144       };
79145     } catch (...) {
79146       {
79147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79148       };
79149     }
79150   }
79151
79152   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79153   return jresult;
79154 }
79155
79156
79157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79158   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79159   Dali::Actor arg2 ;
79160   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79161   std::string *arg4 = 0 ;
79162   Dali::Actor *argp2 ;
79163
79164   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79165   argp2 = (Dali::Actor *)jarg2;
79166   if (!argp2) {
79167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79168     return ;
79169   }
79170   arg2 = *argp2;
79171   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79172   if (!jarg4) {
79173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79174     return ;
79175   }
79176   std::string arg4_str(jarg4);
79177   arg4 = &arg4_str;
79178   {
79179     try {
79180       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79181     } catch (std::out_of_range& e) {
79182       {
79183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79184       };
79185     } catch (std::exception& e) {
79186       {
79187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79188       };
79189     } catch (Dali::DaliException e) {
79190       {
79191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79192       };
79193     } catch (...) {
79194       {
79195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79196       };
79197     }
79198   }
79199
79200
79201   //argout typemap for const std::string&
79202
79203 }
79204
79205
79206 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79207   char * jresult ;
79208   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79209   Dali::Actor arg2 ;
79210   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79211   Dali::Actor *argp2 ;
79212   std::string result;
79213
79214   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79215   argp2 = (Dali::Actor *)jarg2;
79216   if (!argp2) {
79217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79218     return 0;
79219   }
79220   arg2 = *argp2;
79221   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79222   {
79223     try {
79224       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79225     } catch (std::out_of_range& e) {
79226       {
79227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79228       };
79229     } catch (std::exception& e) {
79230       {
79231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79232       };
79233     } catch (Dali::DaliException e) {
79234       {
79235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79236       };
79237     } catch (...) {
79238       {
79239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79240       };
79241     }
79242   }
79243
79244   jresult = SWIG_csharp_string_callback((&result)->c_str());
79245   return jresult;
79246 }
79247
79248
79249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79250   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79251   Dali::Actor arg2 ;
79252   unsigned int arg3 ;
79253   Dali::Actor *argp2 ;
79254
79255   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79256   argp2 = (Dali::Actor *)jarg2;
79257   if (!argp2) {
79258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79259     return ;
79260   }
79261   arg2 = *argp2;
79262   arg3 = (unsigned int)jarg3;
79263   {
79264     try {
79265       (arg1)->SetFocusOrder(arg2,arg3);
79266     } catch (std::out_of_range& e) {
79267       {
79268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79269       };
79270     } catch (std::exception& e) {
79271       {
79272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79273       };
79274     } catch (Dali::DaliException e) {
79275       {
79276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79277       };
79278     } catch (...) {
79279       {
79280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79281       };
79282     }
79283   }
79284
79285 }
79286
79287
79288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79289   unsigned int jresult ;
79290   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79291   Dali::Actor arg2 ;
79292   Dali::Actor *argp2 ;
79293   unsigned int result;
79294
79295   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79296   argp2 = (Dali::Actor *)jarg2;
79297   if (!argp2) {
79298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79299     return 0;
79300   }
79301   arg2 = *argp2;
79302   {
79303     try {
79304       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79305     } catch (std::out_of_range& e) {
79306       {
79307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79308       };
79309     } catch (std::exception& e) {
79310       {
79311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79312       };
79313     } catch (Dali::DaliException e) {
79314       {
79315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79316       };
79317     } catch (...) {
79318       {
79319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79320       };
79321     }
79322   }
79323
79324   jresult = result;
79325   return jresult;
79326 }
79327
79328
79329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79330   unsigned int jresult ;
79331   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79332   unsigned int result;
79333
79334   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79335   {
79336     try {
79337       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79338     } catch (std::out_of_range& e) {
79339       {
79340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79341       };
79342     } catch (std::exception& e) {
79343       {
79344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79345       };
79346     } catch (Dali::DaliException e) {
79347       {
79348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79349       };
79350     } catch (...) {
79351       {
79352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79353       };
79354     }
79355   }
79356
79357   jresult = result;
79358   return jresult;
79359 }
79360
79361
79362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79363   void * jresult ;
79364   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79365   unsigned int arg2 ;
79366   Dali::Actor result;
79367
79368   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79369   arg2 = (unsigned int)jarg2;
79370   {
79371     try {
79372       result = (arg1)->GetActorByFocusOrder(arg2);
79373     } catch (std::out_of_range& e) {
79374       {
79375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79376       };
79377     } catch (std::exception& e) {
79378       {
79379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79380       };
79381     } catch (Dali::DaliException e) {
79382       {
79383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79384       };
79385     } catch (...) {
79386       {
79387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79388       };
79389     }
79390   }
79391
79392   jresult = new Dali::Actor((const Dali::Actor &)result);
79393   return jresult;
79394 }
79395
79396
79397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79398   unsigned int jresult ;
79399   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79400   Dali::Actor arg2 ;
79401   Dali::Actor *argp2 ;
79402   bool result;
79403
79404   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79405   argp2 = (Dali::Actor *)jarg2;
79406   if (!argp2) {
79407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79408     return 0;
79409   }
79410   arg2 = *argp2;
79411   {
79412     try {
79413       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79414     } catch (std::out_of_range& e) {
79415       {
79416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79417       };
79418     } catch (std::exception& e) {
79419       {
79420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79421       };
79422     } catch (Dali::DaliException e) {
79423       {
79424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79425       };
79426     } catch (...) {
79427       {
79428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79429       };
79430     }
79431   }
79432
79433   jresult = result;
79434   return jresult;
79435 }
79436
79437
79438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79439   void * jresult ;
79440   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79441   Dali::Actor result;
79442
79443   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79444   {
79445     try {
79446       result = (arg1)->GetCurrentFocusActor();
79447     } catch (std::out_of_range& e) {
79448       {
79449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79450       };
79451     } catch (std::exception& e) {
79452       {
79453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79454       };
79455     } catch (Dali::DaliException e) {
79456       {
79457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79458       };
79459     } catch (...) {
79460       {
79461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79462       };
79463     }
79464   }
79465
79466   jresult = new Dali::Actor((const Dali::Actor &)result);
79467   return jresult;
79468 }
79469
79470
79471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79472   void * jresult ;
79473   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79474   Dali::Actor result;
79475
79476   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79477   {
79478     try {
79479       result = (arg1)->GetCurrentFocusGroup();
79480     } catch (std::out_of_range& e) {
79481       {
79482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79483       };
79484     } catch (std::exception& e) {
79485       {
79486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79487       };
79488     } catch (Dali::DaliException e) {
79489       {
79490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79491       };
79492     } catch (...) {
79493       {
79494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79495       };
79496     }
79497   }
79498
79499   jresult = new Dali::Actor((const Dali::Actor &)result);
79500   return jresult;
79501 }
79502
79503
79504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79505   unsigned int jresult ;
79506   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79507   unsigned int result;
79508
79509   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79510   {
79511     try {
79512       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79513     } catch (std::out_of_range& e) {
79514       {
79515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79516       };
79517     } catch (std::exception& e) {
79518       {
79519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79520       };
79521     } catch (Dali::DaliException e) {
79522       {
79523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79524       };
79525     } catch (...) {
79526       {
79527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79528       };
79529     }
79530   }
79531
79532   jresult = result;
79533   return jresult;
79534 }
79535
79536
79537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79538   unsigned int jresult ;
79539   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79540   bool result;
79541
79542   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79543   {
79544     try {
79545       result = (bool)(arg1)->MoveFocusForward();
79546     } catch (std::out_of_range& e) {
79547       {
79548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79549       };
79550     } catch (std::exception& e) {
79551       {
79552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79553       };
79554     } catch (Dali::DaliException e) {
79555       {
79556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79557       };
79558     } catch (...) {
79559       {
79560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79561       };
79562     }
79563   }
79564
79565   jresult = result;
79566   return jresult;
79567 }
79568
79569
79570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79571   unsigned int jresult ;
79572   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79573   bool result;
79574
79575   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79576   {
79577     try {
79578       result = (bool)(arg1)->MoveFocusBackward();
79579     } catch (std::out_of_range& e) {
79580       {
79581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79582       };
79583     } catch (std::exception& e) {
79584       {
79585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79586       };
79587     } catch (Dali::DaliException e) {
79588       {
79589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79590       };
79591     } catch (...) {
79592       {
79593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79594       };
79595     }
79596   }
79597
79598   jresult = result;
79599   return jresult;
79600 }
79601
79602
79603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79604   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79605
79606   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79607   {
79608     try {
79609       (arg1)->ClearFocus();
79610     } catch (std::out_of_range& e) {
79611       {
79612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79613       };
79614     } catch (std::exception& e) {
79615       {
79616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79617       };
79618     } catch (Dali::DaliException e) {
79619       {
79620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79621       };
79622     } catch (...) {
79623       {
79624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79625       };
79626     }
79627   }
79628
79629 }
79630
79631
79632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79633   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79634
79635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79636   {
79637     try {
79638       (arg1)->Reset();
79639     } catch (std::out_of_range& e) {
79640       {
79641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79642       };
79643     } catch (std::exception& e) {
79644       {
79645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79646       };
79647     } catch (Dali::DaliException e) {
79648       {
79649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79650       };
79651     } catch (...) {
79652       {
79653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79654       };
79655     }
79656   }
79657
79658 }
79659
79660
79661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79662   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79663   Dali::Actor arg2 ;
79664   bool arg3 ;
79665   Dali::Actor *argp2 ;
79666
79667   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79668   argp2 = (Dali::Actor *)jarg2;
79669   if (!argp2) {
79670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79671     return ;
79672   }
79673   arg2 = *argp2;
79674   arg3 = jarg3 ? true : false;
79675   {
79676     try {
79677       (arg1)->SetFocusGroup(arg2,arg3);
79678     } catch (std::out_of_range& e) {
79679       {
79680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79681       };
79682     } catch (std::exception& e) {
79683       {
79684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79685       };
79686     } catch (Dali::DaliException e) {
79687       {
79688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79689       };
79690     } catch (...) {
79691       {
79692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79693       };
79694     }
79695   }
79696
79697 }
79698
79699
79700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79701   unsigned int jresult ;
79702   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79703   Dali::Actor arg2 ;
79704   Dali::Actor *argp2 ;
79705   bool result;
79706
79707   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79708   argp2 = (Dali::Actor *)jarg2;
79709   if (!argp2) {
79710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79711     return 0;
79712   }
79713   arg2 = *argp2;
79714   {
79715     try {
79716       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79717     } catch (std::out_of_range& e) {
79718       {
79719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79720       };
79721     } catch (std::exception& e) {
79722       {
79723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79724       };
79725     } catch (Dali::DaliException e) {
79726       {
79727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79728       };
79729     } catch (...) {
79730       {
79731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79732       };
79733     }
79734   }
79735
79736   jresult = result;
79737   return jresult;
79738 }
79739
79740
79741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79742   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79743   bool arg2 ;
79744
79745   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79746   arg2 = jarg2 ? true : false;
79747   {
79748     try {
79749       (arg1)->SetGroupMode(arg2);
79750     } catch (std::out_of_range& e) {
79751       {
79752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79753       };
79754     } catch (std::exception& e) {
79755       {
79756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79757       };
79758     } catch (Dali::DaliException e) {
79759       {
79760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79761       };
79762     } catch (...) {
79763       {
79764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79765       };
79766     }
79767   }
79768
79769 }
79770
79771
79772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79773   unsigned int jresult ;
79774   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79775   bool result;
79776
79777   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79778   {
79779     try {
79780       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79781     } catch (std::out_of_range& e) {
79782       {
79783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79784       };
79785     } catch (std::exception& e) {
79786       {
79787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79788       };
79789     } catch (Dali::DaliException e) {
79790       {
79791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79792       };
79793     } catch (...) {
79794       {
79795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79796       };
79797     }
79798   }
79799
79800   jresult = result;
79801   return jresult;
79802 }
79803
79804
79805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79806   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79807   bool arg2 ;
79808
79809   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79810   arg2 = jarg2 ? true : false;
79811   {
79812     try {
79813       (arg1)->SetWrapMode(arg2);
79814     } catch (std::out_of_range& e) {
79815       {
79816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79817       };
79818     } catch (std::exception& e) {
79819       {
79820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79821       };
79822     } catch (Dali::DaliException e) {
79823       {
79824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79825       };
79826     } catch (...) {
79827       {
79828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79829       };
79830     }
79831   }
79832
79833 }
79834
79835
79836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79837   unsigned int jresult ;
79838   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79839   bool result;
79840
79841   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79842   {
79843     try {
79844       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79845     } catch (std::out_of_range& e) {
79846       {
79847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79848       };
79849     } catch (std::exception& e) {
79850       {
79851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79852       };
79853     } catch (Dali::DaliException e) {
79854       {
79855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79856       };
79857     } catch (...) {
79858       {
79859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79860       };
79861     }
79862   }
79863
79864   jresult = result;
79865   return jresult;
79866 }
79867
79868
79869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79870   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79871   Dali::Actor arg2 ;
79872   Dali::Actor *argp2 ;
79873
79874   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79875   argp2 = (Dali::Actor *)jarg2;
79876   if (!argp2) {
79877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79878     return ;
79879   }
79880   arg2 = *argp2;
79881   {
79882     try {
79883       (arg1)->SetFocusIndicatorActor(arg2);
79884     } catch (std::out_of_range& e) {
79885       {
79886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79887       };
79888     } catch (std::exception& e) {
79889       {
79890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79891       };
79892     } catch (Dali::DaliException e) {
79893       {
79894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79895       };
79896     } catch (...) {
79897       {
79898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79899       };
79900     }
79901   }
79902
79903 }
79904
79905
79906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79907   void * jresult ;
79908   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79909   Dali::Actor result;
79910
79911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79912   {
79913     try {
79914       result = (arg1)->GetFocusIndicatorActor();
79915     } catch (std::out_of_range& e) {
79916       {
79917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79918       };
79919     } catch (std::exception& e) {
79920       {
79921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79922       };
79923     } catch (Dali::DaliException e) {
79924       {
79925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79926       };
79927     } catch (...) {
79928       {
79929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79930       };
79931     }
79932   }
79933
79934   jresult = new Dali::Actor((const Dali::Actor &)result);
79935   return jresult;
79936 }
79937
79938
79939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79940   void * jresult ;
79941   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79942   Dali::Actor arg2 ;
79943   Dali::Actor *argp2 ;
79944   Dali::Actor result;
79945
79946   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79947   argp2 = (Dali::Actor *)jarg2;
79948   if (!argp2) {
79949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79950     return 0;
79951   }
79952   arg2 = *argp2;
79953   {
79954     try {
79955       result = (arg1)->GetFocusGroup(arg2);
79956     } catch (std::out_of_range& e) {
79957       {
79958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79959       };
79960     } catch (std::exception& e) {
79961       {
79962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79963       };
79964     } catch (Dali::DaliException e) {
79965       {
79966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79967       };
79968     } catch (...) {
79969       {
79970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79971       };
79972     }
79973   }
79974
79975   jresult = new Dali::Actor((const Dali::Actor &)result);
79976   return jresult;
79977 }
79978
79979
79980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79981   void * jresult ;
79982   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79983   Dali::Vector2 result;
79984
79985   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79986   {
79987     try {
79988       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79989     } catch (std::out_of_range& e) {
79990       {
79991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79992       };
79993     } catch (std::exception& e) {
79994       {
79995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79996       };
79997     } catch (Dali::DaliException e) {
79998       {
79999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80000       };
80001     } catch (...) {
80002       {
80003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80004       };
80005     }
80006   }
80007
80008   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80009   return jresult;
80010 }
80011
80012
80013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80014   void * jresult ;
80015   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80016   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80017
80018   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80019   {
80020     try {
80021       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80022     } catch (std::out_of_range& e) {
80023       {
80024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80025       };
80026     } catch (std::exception& e) {
80027       {
80028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80029       };
80030     } catch (Dali::DaliException e) {
80031       {
80032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80033       };
80034     } catch (...) {
80035       {
80036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80037       };
80038     }
80039   }
80040
80041   jresult = (void *)result;
80042   return jresult;
80043 }
80044
80045
80046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80047   void * jresult ;
80048   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80049   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80050
80051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80052   {
80053     try {
80054       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80055     } catch (std::out_of_range& e) {
80056       {
80057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80058       };
80059     } catch (std::exception& e) {
80060       {
80061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80062       };
80063     } catch (Dali::DaliException e) {
80064       {
80065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80066       };
80067     } catch (...) {
80068       {
80069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80070       };
80071     }
80072   }
80073
80074   jresult = (void *)result;
80075   return jresult;
80076 }
80077
80078
80079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80080   void * jresult ;
80081   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80082   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80083
80084   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80085   {
80086     try {
80087       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80088     } catch (std::out_of_range& e) {
80089       {
80090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80091       };
80092     } catch (std::exception& e) {
80093       {
80094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80095       };
80096     } catch (Dali::DaliException e) {
80097       {
80098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80099       };
80100     } catch (...) {
80101       {
80102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80103       };
80104     }
80105   }
80106
80107   jresult = (void *)result;
80108   return jresult;
80109 }
80110
80111
80112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80113   void * jresult ;
80114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80115   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80116
80117   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80118   {
80119     try {
80120       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80121     } catch (std::out_of_range& e) {
80122       {
80123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80124       };
80125     } catch (std::exception& e) {
80126       {
80127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80128       };
80129     } catch (Dali::DaliException e) {
80130       {
80131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80132       };
80133     } catch (...) {
80134       {
80135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80136       };
80137     }
80138   }
80139
80140   jresult = (void *)result;
80141   return jresult;
80142 }
80143
80144
80145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80146   void * jresult ;
80147   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80148   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80149
80150   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80151   {
80152     try {
80153       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80154     } catch (std::out_of_range& e) {
80155       {
80156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80157       };
80158     } catch (std::exception& e) {
80159       {
80160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80161       };
80162     } catch (Dali::DaliException e) {
80163       {
80164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80165       };
80166     } catch (...) {
80167       {
80168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80169       };
80170     }
80171   }
80172
80173   jresult = (void *)result;
80174   return jresult;
80175 }
80176
80177
80178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80179   void * jresult ;
80180   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80181   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80182
80183   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80184   {
80185     try {
80186       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80187     } catch (std::out_of_range& e) {
80188       {
80189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80190       };
80191     } catch (std::exception& e) {
80192       {
80193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80194       };
80195     } catch (Dali::DaliException e) {
80196       {
80197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80198       };
80199     } catch (...) {
80200       {
80201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80202       };
80203     }
80204   }
80205
80206   jresult = (void *)result;
80207   return jresult;
80208 }
80209
80210
80211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80212   void * jresult ;
80213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80214   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80215
80216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80217   {
80218     try {
80219       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80220     } catch (std::out_of_range& e) {
80221       {
80222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80223       };
80224     } catch (std::exception& e) {
80225       {
80226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80227       };
80228     } catch (Dali::DaliException e) {
80229       {
80230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80231       };
80232     } catch (...) {
80233       {
80234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80235       };
80236     }
80237   }
80238
80239   jresult = (void *)result;
80240   return jresult;
80241 }
80242
80243
80244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80245   void * jresult ;
80246   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80247   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80248
80249   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80250   {
80251     try {
80252       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80253     } catch (std::out_of_range& e) {
80254       {
80255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80256       };
80257     } catch (std::exception& e) {
80258       {
80259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80260       };
80261     } catch (Dali::DaliException e) {
80262       {
80263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80264       };
80265     } catch (...) {
80266       {
80267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80268       };
80269     }
80270   }
80271
80272   jresult = (void *)result;
80273   return jresult;
80274 }
80275
80276
80277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80278   void * jresult ;
80279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80280   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80281
80282   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80283   {
80284     try {
80285       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80286     } catch (std::out_of_range& e) {
80287       {
80288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80289       };
80290     } catch (std::exception& e) {
80291       {
80292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80293       };
80294     } catch (Dali::DaliException e) {
80295       {
80296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80297       };
80298     } catch (...) {
80299       {
80300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80301       };
80302     }
80303   }
80304
80305   jresult = (void *)result;
80306   return jresult;
80307 }
80308
80309
80310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80311   void * jresult ;
80312   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80313   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80314
80315   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80316   {
80317     try {
80318       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80319     } catch (std::out_of_range& e) {
80320       {
80321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80322       };
80323     } catch (std::exception& e) {
80324       {
80325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80326       };
80327     } catch (Dali::DaliException e) {
80328       {
80329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80330       };
80331     } catch (...) {
80332       {
80333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80334       };
80335     }
80336   }
80337
80338   jresult = (void *)result;
80339   return jresult;
80340 }
80341
80342
80343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80344   void * jresult ;
80345   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80346   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80347
80348   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80349   {
80350     try {
80351       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80352     } catch (std::out_of_range& e) {
80353       {
80354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80355       };
80356     } catch (std::exception& e) {
80357       {
80358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80359       };
80360     } catch (Dali::DaliException e) {
80361       {
80362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80363       };
80364     } catch (...) {
80365       {
80366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80367       };
80368     }
80369   }
80370
80371   jresult = (void *)result;
80372   return jresult;
80373 }
80374
80375
80376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80377   void * jresult ;
80378   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80379   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80380
80381   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80382   {
80383     try {
80384       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80385     } catch (std::out_of_range& e) {
80386       {
80387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80388       };
80389     } catch (std::exception& e) {
80390       {
80391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80392       };
80393     } catch (Dali::DaliException e) {
80394       {
80395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80396       };
80397     } catch (...) {
80398       {
80399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80400       };
80401     }
80402   }
80403
80404   jresult = (void *)result;
80405   return jresult;
80406 }
80407
80408
80409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80410   void * jresult ;
80411   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80412   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80413
80414   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80415   {
80416     try {
80417       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80418     } catch (std::out_of_range& e) {
80419       {
80420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80421       };
80422     } catch (std::exception& e) {
80423       {
80424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80425       };
80426     } catch (Dali::DaliException e) {
80427       {
80428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80429       };
80430     } catch (...) {
80431       {
80432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80433       };
80434     }
80435   }
80436
80437   jresult = (void *)result;
80438   return jresult;
80439 }
80440
80441
80442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80443   void * jresult ;
80444   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80445   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80446
80447   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80448   {
80449     try {
80450       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80451     } catch (std::out_of_range& e) {
80452       {
80453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80454       };
80455     } catch (std::exception& e) {
80456       {
80457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80458       };
80459     } catch (Dali::DaliException e) {
80460       {
80461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80462       };
80463     } catch (...) {
80464       {
80465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80466       };
80467     }
80468   }
80469
80470   jresult = (void *)result;
80471   return jresult;
80472 }
80473
80474
80475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80476   void * jresult ;
80477   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80478   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80479
80480   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80481   {
80482     try {
80483       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80484     } catch (std::out_of_range& e) {
80485       {
80486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80487       };
80488     } catch (std::exception& e) {
80489       {
80490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80491       };
80492     } catch (Dali::DaliException e) {
80493       {
80494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80495       };
80496     } catch (...) {
80497       {
80498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80499       };
80500     }
80501   }
80502
80503   jresult = (void *)result;
80504   return jresult;
80505 }
80506
80507
80508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80509   void * jresult ;
80510   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80511   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80512
80513   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80514   {
80515     try {
80516       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80517     } catch (std::out_of_range& e) {
80518       {
80519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80520       };
80521     } catch (std::exception& e) {
80522       {
80523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80524       };
80525     } catch (Dali::DaliException e) {
80526       {
80527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80528       };
80529     } catch (...) {
80530       {
80531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80532       };
80533     }
80534   }
80535
80536   jresult = (void *)result;
80537   return jresult;
80538 }
80539
80540
80541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80542   void * jresult ;
80543   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80544   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80545
80546   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80547   {
80548     try {
80549       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80550     } catch (std::out_of_range& e) {
80551       {
80552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80553       };
80554     } catch (std::exception& e) {
80555       {
80556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80557       };
80558     } catch (Dali::DaliException e) {
80559       {
80560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80561       };
80562     } catch (...) {
80563       {
80564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80565       };
80566     }
80567   }
80568
80569   jresult = (void *)result;
80570   return jresult;
80571 }
80572
80573
80574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80575   void * jresult ;
80576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80577   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80578
80579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80580   {
80581     try {
80582       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80583     } catch (std::out_of_range& e) {
80584       {
80585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80586       };
80587     } catch (std::exception& e) {
80588       {
80589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80590       };
80591     } catch (Dali::DaliException e) {
80592       {
80593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80594       };
80595     } catch (...) {
80596       {
80597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80598       };
80599     }
80600   }
80601
80602   jresult = (void *)result;
80603   return jresult;
80604 }
80605
80606
80607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80608   void * jresult ;
80609   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80610   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80611
80612   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80613   {
80614     try {
80615       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80616     } catch (std::out_of_range& e) {
80617       {
80618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80619       };
80620     } catch (std::exception& e) {
80621       {
80622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80623       };
80624     } catch (Dali::DaliException e) {
80625       {
80626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80627       };
80628     } catch (...) {
80629       {
80630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80631       };
80632     }
80633   }
80634
80635   jresult = (void *)result;
80636   return jresult;
80637 }
80638
80639
80640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80641   void * jresult ;
80642   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80643   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80644
80645   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80646   {
80647     try {
80648       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80649     } catch (std::out_of_range& e) {
80650       {
80651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80652       };
80653     } catch (std::exception& e) {
80654       {
80655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80656       };
80657     } catch (Dali::DaliException e) {
80658       {
80659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80660       };
80661     } catch (...) {
80662       {
80663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80664       };
80665     }
80666   }
80667
80668   jresult = (void *)result;
80669   return jresult;
80670 }
80671
80672
80673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80674   void * jresult ;
80675   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80676   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80677
80678   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80679   {
80680     try {
80681       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80682     } catch (std::out_of_range& e) {
80683       {
80684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80685       };
80686     } catch (std::exception& e) {
80687       {
80688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80689       };
80690     } catch (Dali::DaliException e) {
80691       {
80692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80693       };
80694     } catch (...) {
80695       {
80696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80697       };
80698     }
80699   }
80700
80701   jresult = (void *)result;
80702   return jresult;
80703 }
80704
80705
80706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80707   void * jresult ;
80708   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80709   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80710
80711   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80712   {
80713     try {
80714       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80715     } catch (std::out_of_range& e) {
80716       {
80717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80718       };
80719     } catch (std::exception& e) {
80720       {
80721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80722       };
80723     } catch (Dali::DaliException e) {
80724       {
80725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80726       };
80727     } catch (...) {
80728       {
80729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80730       };
80731     }
80732   }
80733
80734   jresult = (void *)result;
80735   return jresult;
80736 }
80737
80738
80739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80740   void * jresult ;
80741   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80742   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80743
80744   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80745   {
80746     try {
80747       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80748     } catch (std::out_of_range& e) {
80749       {
80750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80751       };
80752     } catch (std::exception& e) {
80753       {
80754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80755       };
80756     } catch (Dali::DaliException e) {
80757       {
80758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80759       };
80760     } catch (...) {
80761       {
80762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80763       };
80764     }
80765   }
80766
80767   jresult = (void *)result;
80768   return jresult;
80769 }
80770
80771
80772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80773   void * jresult ;
80774   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80775   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80776
80777   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80778   {
80779     try {
80780       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80781     } catch (std::out_of_range& e) {
80782       {
80783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80784       };
80785     } catch (std::exception& e) {
80786       {
80787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80788       };
80789     } catch (Dali::DaliException e) {
80790       {
80791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80792       };
80793     } catch (...) {
80794       {
80795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80796       };
80797     }
80798   }
80799
80800   jresult = (void *)result;
80801   return jresult;
80802 }
80803
80804
80805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80806   void * jresult ;
80807   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80808   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80809
80810   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80811   {
80812     try {
80813       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80814     } catch (std::out_of_range& e) {
80815       {
80816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80817       };
80818     } catch (std::exception& e) {
80819       {
80820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80821       };
80822     } catch (Dali::DaliException e) {
80823       {
80824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80825       };
80826     } catch (...) {
80827       {
80828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80829       };
80830     }
80831   }
80832
80833   jresult = (void *)result;
80834   return jresult;
80835 }
80836
80837
80838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80839   void * jresult ;
80840   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80841   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80842
80843   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80844   {
80845     try {
80846       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80847     } catch (std::out_of_range& e) {
80848       {
80849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80850       };
80851     } catch (std::exception& e) {
80852       {
80853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80854       };
80855     } catch (Dali::DaliException e) {
80856       {
80857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80858       };
80859     } catch (...) {
80860       {
80861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80862       };
80863     }
80864   }
80865
80866   jresult = (void *)result;
80867   return jresult;
80868 }
80869
80870
80871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80872   void * jresult ;
80873   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80874   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80875
80876   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80877   {
80878     try {
80879       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80880     } catch (std::out_of_range& e) {
80881       {
80882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80883       };
80884     } catch (std::exception& e) {
80885       {
80886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80887       };
80888     } catch (Dali::DaliException e) {
80889       {
80890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80891       };
80892     } catch (...) {
80893       {
80894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80895       };
80896     }
80897   }
80898
80899   jresult = (void *)result;
80900   return jresult;
80901 }
80902
80903
80904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80905   void * jresult ;
80906   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80907   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80908
80909   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80910   {
80911     try {
80912       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80913     } catch (std::out_of_range& e) {
80914       {
80915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80916       };
80917     } catch (std::exception& e) {
80918       {
80919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80920       };
80921     } catch (Dali::DaliException e) {
80922       {
80923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80924       };
80925     } catch (...) {
80926       {
80927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80928       };
80929     }
80930   }
80931
80932   jresult = (void *)result;
80933   return jresult;
80934 }
80935
80936
80937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80938   void * jresult ;
80939   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80940   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80941
80942   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80943   {
80944     try {
80945       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80946     } catch (std::out_of_range& e) {
80947       {
80948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80949       };
80950     } catch (std::exception& e) {
80951       {
80952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80953       };
80954     } catch (Dali::DaliException e) {
80955       {
80956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80957       };
80958     } catch (...) {
80959       {
80960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80961       };
80962     }
80963   }
80964
80965   jresult = (void *)result;
80966   return jresult;
80967 }
80968
80969
80970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80971   void * jresult ;
80972   Dali::Toolkit::StyleManager *result = 0 ;
80973
80974   {
80975     try {
80976       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80977     } catch (std::out_of_range& e) {
80978       {
80979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80980       };
80981     } catch (std::exception& e) {
80982       {
80983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80984       };
80985     } catch (Dali::DaliException e) {
80986       {
80987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80988       };
80989     } catch (...) {
80990       {
80991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80992       };
80993     }
80994   }
80995
80996   jresult = (void *)result;
80997   return jresult;
80998 }
80999
81000
81001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81002   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81003
81004   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81005   {
81006     try {
81007       delete arg1;
81008     } catch (std::out_of_range& e) {
81009       {
81010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81011       };
81012     } catch (std::exception& e) {
81013       {
81014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81015       };
81016     } catch (Dali::DaliException e) {
81017       {
81018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81019       };
81020     } catch (...) {
81021       {
81022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81023       };
81024     }
81025   }
81026
81027 }
81028
81029
81030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81031   void * jresult ;
81032   Dali::Toolkit::StyleManager result;
81033
81034   {
81035     try {
81036       result = Dali::Toolkit::StyleManager::Get();
81037     } catch (std::out_of_range& e) {
81038       {
81039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81040       };
81041     } catch (std::exception& e) {
81042       {
81043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81044       };
81045     } catch (Dali::DaliException e) {
81046       {
81047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81048       };
81049     } catch (...) {
81050       {
81051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81052       };
81053     }
81054   }
81055
81056   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81057   return jresult;
81058 }
81059
81060
81061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81062   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81063   std::string *arg2 = 0 ;
81064
81065   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81066   if (!jarg2) {
81067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81068     return ;
81069   }
81070   std::string arg2_str(jarg2);
81071   arg2 = &arg2_str;
81072   {
81073     try {
81074       (arg1)->ApplyTheme((std::string const &)*arg2);
81075     } catch (std::out_of_range& e) {
81076       {
81077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81078       };
81079     } catch (std::exception& e) {
81080       {
81081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81082       };
81083     } catch (Dali::DaliException e) {
81084       {
81085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81086       };
81087     } catch (...) {
81088       {
81089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81090       };
81091     }
81092   }
81093
81094
81095   //argout typemap for const std::string&
81096
81097 }
81098
81099
81100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81101   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81102
81103   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81104   {
81105     try {
81106       (arg1)->ApplyDefaultTheme();
81107     } catch (std::out_of_range& e) {
81108       {
81109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81110       };
81111     } catch (std::exception& e) {
81112       {
81113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81114       };
81115     } catch (Dali::DaliException e) {
81116       {
81117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81118       };
81119     } catch (...) {
81120       {
81121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81122       };
81123     }
81124   }
81125
81126 }
81127
81128
81129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81130   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81131   std::string *arg2 = 0 ;
81132   Dali::Property::Value *arg3 = 0 ;
81133
81134   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81135   if (!jarg2) {
81136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81137     return ;
81138   }
81139   std::string arg2_str(jarg2);
81140   arg2 = &arg2_str;
81141   arg3 = (Dali::Property::Value *)jarg3;
81142   if (!arg3) {
81143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81144     return ;
81145   }
81146   {
81147     try {
81148       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81149     } catch (std::out_of_range& e) {
81150       {
81151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81152       };
81153     } catch (std::exception& e) {
81154       {
81155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81156       };
81157     } catch (Dali::DaliException e) {
81158       {
81159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81160       };
81161     } catch (...) {
81162       {
81163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81164       };
81165     }
81166   }
81167
81168
81169   //argout typemap for const std::string&
81170
81171 }
81172
81173
81174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81175   unsigned int jresult ;
81176   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81177   std::string *arg2 = 0 ;
81178   Dali::Property::Value *arg3 = 0 ;
81179   bool result;
81180
81181   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81182   if (!jarg2) {
81183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81184     return 0;
81185   }
81186   std::string arg2_str(jarg2);
81187   arg2 = &arg2_str;
81188   arg3 = (Dali::Property::Value *)jarg3;
81189   if (!arg3) {
81190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81191     return 0;
81192   }
81193   {
81194     try {
81195       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81196     } catch (std::out_of_range& e) {
81197       {
81198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81199       };
81200     } catch (std::exception& e) {
81201       {
81202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81203       };
81204     } catch (Dali::DaliException e) {
81205       {
81206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81207       };
81208     } catch (...) {
81209       {
81210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81211       };
81212     }
81213   }
81214
81215   jresult = result;
81216
81217   //argout typemap for const std::string&
81218
81219   return jresult;
81220 }
81221
81222
81223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81224   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81225   Dali::Toolkit::Control arg2 ;
81226   std::string *arg3 = 0 ;
81227   std::string *arg4 = 0 ;
81228   Dali::Toolkit::Control *argp2 ;
81229
81230   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81231   argp2 = (Dali::Toolkit::Control *)jarg2;
81232   if (!argp2) {
81233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81234     return ;
81235   }
81236   arg2 = *argp2;
81237   if (!jarg3) {
81238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81239     return ;
81240   }
81241   std::string arg3_str(jarg3);
81242   arg3 = &arg3_str;
81243   if (!jarg4) {
81244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81245     return ;
81246   }
81247   std::string arg4_str(jarg4);
81248   arg4 = &arg4_str;
81249   {
81250     try {
81251       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81252     } catch (std::out_of_range& e) {
81253       {
81254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81255       };
81256     } catch (std::exception& e) {
81257       {
81258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81259       };
81260     } catch (Dali::DaliException e) {
81261       {
81262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81263       };
81264     } catch (...) {
81265       {
81266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81267       };
81268     }
81269   }
81270
81271
81272   //argout typemap for const std::string&
81273
81274
81275   //argout typemap for const std::string&
81276
81277 }
81278
81279
81280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81281   void * jresult ;
81282   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81283   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81284
81285   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81286   {
81287     try {
81288       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81289     } catch (std::out_of_range& e) {
81290       {
81291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81292       };
81293     } catch (std::exception& e) {
81294       {
81295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81296       };
81297     } catch (Dali::DaliException e) {
81298       {
81299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81300       };
81301     } catch (...) {
81302       {
81303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81304       };
81305     }
81306   }
81307
81308   jresult = (void *)result;
81309   return jresult;
81310 }
81311
81312
81313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81314   int jresult ;
81315   int result;
81316
81317   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81318   jresult = (int)result;
81319   return jresult;
81320 }
81321
81322
81323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81324   int jresult ;
81325   int result;
81326
81327   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81328   jresult = (int)result;
81329   return jresult;
81330 }
81331
81332
81333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81334   int jresult ;
81335   int result;
81336
81337   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81338   jresult = (int)result;
81339   return jresult;
81340 }
81341
81342
81343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81344   int jresult ;
81345   int result;
81346
81347   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81348   jresult = (int)result;
81349   return jresult;
81350 }
81351
81352
81353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81354   int jresult ;
81355   int result;
81356
81357   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81358   jresult = (int)result;
81359   return jresult;
81360 }
81361
81362
81363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81364   int jresult ;
81365   int result;
81366
81367   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81368   jresult = (int)result;
81369   return jresult;
81370 }
81371
81372
81373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81374   int jresult ;
81375   int result;
81376
81377   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81378   jresult = (int)result;
81379   return jresult;
81380 }
81381
81382
81383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81384   int jresult ;
81385   int result;
81386
81387   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81388   jresult = (int)result;
81389   return jresult;
81390 }
81391
81392
81393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81394   int jresult ;
81395   int result;
81396
81397   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81398   jresult = (int)result;
81399   return jresult;
81400 }
81401
81402
81403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81404   int jresult ;
81405   int result;
81406
81407   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81408   jresult = (int)result;
81409   return jresult;
81410 }
81411
81412
81413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81414   int jresult ;
81415   int result;
81416
81417   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81418   jresult = (int)result;
81419   return jresult;
81420 }
81421
81422
81423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81424   int jresult ;
81425   int result;
81426
81427   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81428   jresult = (int)result;
81429   return jresult;
81430 }
81431
81432
81433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81434   int jresult ;
81435   int result;
81436
81437   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81438   jresult = (int)result;
81439   return jresult;
81440 }
81441
81442
81443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81444   int jresult ;
81445   int result;
81446
81447   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81448   jresult = (int)result;
81449   return jresult;
81450 }
81451
81452
81453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81454   int jresult ;
81455   int result;
81456
81457   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81458   jresult = (int)result;
81459   return jresult;
81460 }
81461
81462
81463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81464   void * jresult ;
81465   Dali::Toolkit::Slider::Property *result = 0 ;
81466
81467   {
81468     try {
81469       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81470     } catch (std::out_of_range& e) {
81471       {
81472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81473       };
81474     } catch (std::exception& e) {
81475       {
81476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81477       };
81478     } catch (Dali::DaliException e) {
81479       {
81480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81481       };
81482     } catch (...) {
81483       {
81484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81485       };
81486     }
81487   }
81488
81489   jresult = (void *)result;
81490   return jresult;
81491 }
81492
81493
81494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81495   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81496
81497   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81498   {
81499     try {
81500       delete arg1;
81501     } catch (std::out_of_range& e) {
81502       {
81503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81504       };
81505     } catch (std::exception& e) {
81506       {
81507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81508       };
81509     } catch (Dali::DaliException e) {
81510       {
81511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81512       };
81513     } catch (...) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81516       };
81517     }
81518   }
81519
81520 }
81521
81522
81523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81524   void * jresult ;
81525   Dali::Toolkit::Slider result;
81526
81527   {
81528     try {
81529       result = Dali::Toolkit::Slider::New();
81530     } catch (std::out_of_range& e) {
81531       {
81532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81533       };
81534     } catch (std::exception& e) {
81535       {
81536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81537       };
81538     } catch (Dali::DaliException e) {
81539       {
81540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81541       };
81542     } catch (...) {
81543       {
81544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81545       };
81546     }
81547   }
81548
81549   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81550   return jresult;
81551 }
81552
81553
81554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81555   void * jresult ;
81556   Dali::Toolkit::Slider *result = 0 ;
81557
81558   {
81559     try {
81560       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81561     } catch (std::out_of_range& e) {
81562       {
81563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81564       };
81565     } catch (std::exception& e) {
81566       {
81567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81568       };
81569     } catch (Dali::DaliException e) {
81570       {
81571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81572       };
81573     } catch (...) {
81574       {
81575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81576       };
81577     }
81578   }
81579
81580   jresult = (void *)result;
81581   return jresult;
81582 }
81583
81584
81585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81586   void * jresult ;
81587   Dali::Toolkit::Slider *arg1 = 0 ;
81588   Dali::Toolkit::Slider *result = 0 ;
81589
81590   arg1 = (Dali::Toolkit::Slider *)jarg1;
81591   if (!arg1) {
81592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81593     return 0;
81594   }
81595   {
81596     try {
81597       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81598     } catch (std::out_of_range& e) {
81599       {
81600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81601       };
81602     } catch (std::exception& e) {
81603       {
81604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81605       };
81606     } catch (Dali::DaliException e) {
81607       {
81608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81609       };
81610     } catch (...) {
81611       {
81612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81613       };
81614     }
81615   }
81616
81617   jresult = (void *)result;
81618   return jresult;
81619 }
81620
81621
81622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81623   void * jresult ;
81624   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81625   Dali::Toolkit::Slider *arg2 = 0 ;
81626   Dali::Toolkit::Slider *result = 0 ;
81627
81628   arg1 = (Dali::Toolkit::Slider *)jarg1;
81629   arg2 = (Dali::Toolkit::Slider *)jarg2;
81630   if (!arg2) {
81631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81632     return 0;
81633   }
81634   {
81635     try {
81636       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81637     } catch (std::out_of_range& e) {
81638       {
81639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81640       };
81641     } catch (std::exception& e) {
81642       {
81643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81644       };
81645     } catch (Dali::DaliException e) {
81646       {
81647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81648       };
81649     } catch (...) {
81650       {
81651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81652       };
81653     }
81654   }
81655
81656   jresult = (void *)result;
81657   return jresult;
81658 }
81659
81660
81661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81662   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81663
81664   arg1 = (Dali::Toolkit::Slider *)jarg1;
81665   {
81666     try {
81667       delete arg1;
81668     } catch (std::out_of_range& e) {
81669       {
81670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81671       };
81672     } catch (std::exception& e) {
81673       {
81674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81675       };
81676     } catch (Dali::DaliException e) {
81677       {
81678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81679       };
81680     } catch (...) {
81681       {
81682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81683       };
81684     }
81685   }
81686
81687 }
81688
81689
81690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81691   void * jresult ;
81692   Dali::BaseHandle arg1 ;
81693   Dali::BaseHandle *argp1 ;
81694   Dali::Toolkit::Slider result;
81695
81696   argp1 = (Dali::BaseHandle *)jarg1;
81697   if (!argp1) {
81698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81699     return 0;
81700   }
81701   arg1 = *argp1;
81702   {
81703     try {
81704       result = Dali::Toolkit::Slider::DownCast(arg1);
81705     } catch (std::out_of_range& e) {
81706       {
81707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81708       };
81709     } catch (std::exception& e) {
81710       {
81711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81712       };
81713     } catch (Dali::DaliException e) {
81714       {
81715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81716       };
81717     } catch (...) {
81718       {
81719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81720       };
81721     }
81722   }
81723
81724   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81725   return jresult;
81726 }
81727
81728
81729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81730   void * jresult ;
81731   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81732   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81733
81734   arg1 = (Dali::Toolkit::Slider *)jarg1;
81735   {
81736     try {
81737       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81738     } catch (std::out_of_range& e) {
81739       {
81740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81741       };
81742     } catch (std::exception& e) {
81743       {
81744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81745       };
81746     } catch (Dali::DaliException e) {
81747       {
81748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81749       };
81750     } catch (...) {
81751       {
81752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81753       };
81754     }
81755   }
81756
81757   jresult = (void *)result;
81758   return jresult;
81759 }
81760
81761
81762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81763   void * jresult ;
81764   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81765   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81766
81767   arg1 = (Dali::Toolkit::Slider *)jarg1;
81768   {
81769     try {
81770       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81771     } catch (std::out_of_range& e) {
81772       {
81773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81774       };
81775     } catch (std::exception& e) {
81776       {
81777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81778       };
81779     } catch (Dali::DaliException e) {
81780       {
81781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81782       };
81783     } catch (...) {
81784       {
81785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81786       };
81787     }
81788   }
81789
81790   jresult = (void *)result;
81791   return jresult;
81792 }
81793
81794
81795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81796   void * jresult ;
81797   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81798   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81799
81800   arg1 = (Dali::Toolkit::Slider *)jarg1;
81801   {
81802     try {
81803       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81804     } catch (std::out_of_range& e) {
81805       {
81806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81807       };
81808     } catch (std::exception& e) {
81809       {
81810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81811       };
81812     } catch (Dali::DaliException e) {
81813       {
81814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81815       };
81816     } catch (...) {
81817       {
81818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81819       };
81820     }
81821   }
81822
81823   jresult = (void *)result;
81824   return jresult;
81825 }
81826
81827
81828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81829   int jresult ;
81830   int result;
81831
81832   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81833   jresult = (int)result;
81834   return jresult;
81835 }
81836
81837
81838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81839   int jresult ;
81840   int result;
81841
81842   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81843   jresult = (int)result;
81844   return jresult;
81845 }
81846
81847
81848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81849   int jresult ;
81850   int result;
81851
81852   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81853   jresult = (int)result;
81854   return jresult;
81855 }
81856
81857
81858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81859   int jresult ;
81860   int result;
81861
81862   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81863   jresult = (int)result;
81864   return jresult;
81865 }
81866
81867
81868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
81869   int result;
81870
81871   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
81872
81873   return result;
81874 }
81875
81876
81877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81878   void * jresult ;
81879   Dali::Toolkit::VideoView::Property *result = 0 ;
81880
81881   {
81882     try {
81883       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81884     } catch (std::out_of_range& e) {
81885       {
81886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81887       };
81888     } catch (std::exception& e) {
81889       {
81890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81891       };
81892     } catch (Dali::DaliException e) {
81893       {
81894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81895       };
81896     } catch (...) {
81897       {
81898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81899       };
81900     }
81901   }
81902
81903   jresult = (void *)result;
81904   return jresult;
81905 }
81906
81907
81908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81909   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81910
81911   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81912   {
81913     try {
81914       delete arg1;
81915     } catch (std::out_of_range& e) {
81916       {
81917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81918       };
81919     } catch (std::exception& e) {
81920       {
81921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81922       };
81923     } catch (Dali::DaliException e) {
81924       {
81925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81926       };
81927     } catch (...) {
81928       {
81929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81930       };
81931     }
81932   }
81933
81934 }
81935
81936
81937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81938   void * jresult ;
81939   Dali::Toolkit::VideoView result;
81940
81941   {
81942     try {
81943       result = Dali::Toolkit::VideoView::New();
81944     } catch (std::out_of_range& e) {
81945       {
81946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81947       };
81948     } catch (std::exception& e) {
81949       {
81950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81951       };
81952     } catch (Dali::DaliException e) {
81953       {
81954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81955       };
81956     } catch (...) {
81957       {
81958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81959       };
81960     }
81961   }
81962
81963   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81964   return jresult;
81965 }
81966
81967
81968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81969   void * jresult ;
81970   std::string *arg1 = 0 ;
81971   Dali::Toolkit::VideoView result;
81972
81973   if (!jarg1) {
81974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81975     return 0;
81976   }
81977   std::string arg1_str(jarg1);
81978   arg1 = &arg1_str;
81979   {
81980     try {
81981       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81982     } catch (std::out_of_range& e) {
81983       {
81984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81985       };
81986     } catch (std::exception& e) {
81987       {
81988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81989       };
81990     } catch (Dali::DaliException e) {
81991       {
81992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81993       };
81994     } catch (...) {
81995       {
81996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81997       };
81998     }
81999   }
82000
82001   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82002
82003   //argout typemap for const std::string&
82004
82005   return jresult;
82006 }
82007
82008
82009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
82010   void * jresult ;
82011   Dali::Toolkit::VideoView result;
82012   {
82013     try {
82014       result = Dali::Toolkit::VideoView::New(swCodec);
82015     } catch (std::out_of_range& e) {
82016       {
82017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82018       };
82019     } catch (std::exception& e) {
82020       {
82021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82022       };
82023     } catch (Dali::DaliException e) {
82024       {
82025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82026       };
82027     } catch (...) {
82028       {
82029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82030       };
82031     }
82032   }
82033
82034   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82035
82036   //argout typemap for const std::string&
82037
82038   return jresult;
82039 }
82040
82041
82042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
82043   void * jresult ;
82044   std::string *arg1 = 0 ;
82045   Dali::Toolkit::VideoView result;
82046
82047   if (!jarg1) {
82048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82049     return 0;
82050   }
82051   std::string arg1_str(jarg1);
82052   arg1 = &arg1_str;
82053   {
82054     try {
82055       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
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 = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82076
82077   //argout typemap for const std::string&
82078
82079   return jresult;
82080 }
82081
82082
82083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82084   void * jresult ;
82085   Dali::Toolkit::VideoView *result = 0 ;
82086
82087   {
82088     try {
82089       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82090     } catch (std::out_of_range& e) {
82091       {
82092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82093       };
82094     } catch (std::exception& e) {
82095       {
82096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82097       };
82098     } catch (Dali::DaliException e) {
82099       {
82100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82101       };
82102     } catch (...) {
82103       {
82104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82105       };
82106     }
82107   }
82108
82109   jresult = (void *)result;
82110   return jresult;
82111 }
82112
82113
82114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82115   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82116
82117   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82118   {
82119     try {
82120       delete arg1;
82121     } catch (std::out_of_range& e) {
82122       {
82123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82124       };
82125     } catch (std::exception& e) {
82126       {
82127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82128       };
82129     } catch (Dali::DaliException e) {
82130       {
82131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82132       };
82133     } catch (...) {
82134       {
82135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82136       };
82137     }
82138   }
82139
82140 }
82141
82142
82143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82144   void * jresult ;
82145   Dali::Toolkit::VideoView *arg1 = 0 ;
82146   Dali::Toolkit::VideoView *result = 0 ;
82147
82148   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82149   if (!arg1) {
82150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82151     return 0;
82152   }
82153   {
82154     try {
82155       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82156     } catch (std::out_of_range& e) {
82157       {
82158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82159       };
82160     } catch (std::exception& e) {
82161       {
82162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82163       };
82164     } catch (Dali::DaliException e) {
82165       {
82166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82167       };
82168     } catch (...) {
82169       {
82170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82171       };
82172     }
82173   }
82174
82175   jresult = (void *)result;
82176   return jresult;
82177 }
82178
82179
82180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82181   void * jresult ;
82182   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82183   Dali::Toolkit::VideoView *arg2 = 0 ;
82184   Dali::Toolkit::VideoView *result = 0 ;
82185
82186   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82187   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82188   if (!arg2) {
82189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82190     return 0;
82191   }
82192   {
82193     try {
82194       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82195     } catch (std::out_of_range& e) {
82196       {
82197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82198       };
82199     } catch (std::exception& e) {
82200       {
82201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82202       };
82203     } catch (Dali::DaliException e) {
82204       {
82205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82206       };
82207     } catch (...) {
82208       {
82209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82210       };
82211     }
82212   }
82213
82214   jresult = (void *)result;
82215   return jresult;
82216 }
82217
82218
82219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82220   void * jresult ;
82221   Dali::BaseHandle arg1 ;
82222   Dali::BaseHandle *argp1 ;
82223   Dali::Toolkit::VideoView result;
82224
82225   argp1 = (Dali::BaseHandle *)jarg1;
82226   if (!argp1) {
82227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82228     return 0;
82229   }
82230   arg1 = *argp1;
82231   {
82232     try {
82233       result = Dali::Toolkit::VideoView::DownCast(arg1);
82234     } catch (std::out_of_range& e) {
82235       {
82236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82237       };
82238     } catch (std::exception& e) {
82239       {
82240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82241       };
82242     } catch (Dali::DaliException e) {
82243       {
82244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82245       };
82246     } catch (...) {
82247       {
82248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82249       };
82250     }
82251   }
82252
82253   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82254   return jresult;
82255 }
82256
82257
82258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82259   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82260
82261   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82262   {
82263     try {
82264       (arg1)->Play();
82265     } catch (std::out_of_range& e) {
82266       {
82267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82268       };
82269     } catch (std::exception& e) {
82270       {
82271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82272       };
82273     } catch (Dali::DaliException e) {
82274       {
82275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82276       };
82277     } catch (...) {
82278       {
82279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82280       };
82281     }
82282   }
82283
82284 }
82285
82286
82287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82288   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82289
82290   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82291   {
82292     try {
82293       (arg1)->Pause();
82294     } catch (std::out_of_range& e) {
82295       {
82296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82297       };
82298     } catch (std::exception& e) {
82299       {
82300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82301       };
82302     } catch (Dali::DaliException e) {
82303       {
82304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82305       };
82306     } catch (...) {
82307       {
82308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82309       };
82310     }
82311   }
82312
82313 }
82314
82315
82316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82317   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82318
82319   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82320   {
82321     try {
82322       (arg1)->Stop();
82323     } catch (std::out_of_range& e) {
82324       {
82325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82326       };
82327     } catch (std::exception& e) {
82328       {
82329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82330       };
82331     } catch (Dali::DaliException e) {
82332       {
82333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82334       };
82335     } catch (...) {
82336       {
82337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82338       };
82339     }
82340   }
82341
82342 }
82343
82344
82345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82346   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82347   int arg2 ;
82348
82349   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82350   arg2 = (int)jarg2;
82351   {
82352     try {
82353       (arg1)->Forward(arg2);
82354     } catch (std::out_of_range& e) {
82355       {
82356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82357       };
82358     } catch (std::exception& e) {
82359       {
82360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82361       };
82362     } catch (Dali::DaliException e) {
82363       {
82364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82365       };
82366     } catch (...) {
82367       {
82368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82369       };
82370     }
82371   }
82372
82373 }
82374
82375
82376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82377   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82378   int arg2 ;
82379
82380   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82381   arg2 = (int)jarg2;
82382   {
82383     try {
82384       (arg1)->Backward(arg2);
82385     } catch (std::out_of_range& e) {
82386       {
82387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82388       };
82389     } catch (std::exception& e) {
82390       {
82391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82392       };
82393     } catch (Dali::DaliException e) {
82394       {
82395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82396       };
82397     } catch (...) {
82398       {
82399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82400       };
82401     }
82402   }
82403
82404 }
82405
82406
82407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82408   void * jresult ;
82409   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82410   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82411
82412   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82413   {
82414     try {
82415       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82416     } catch (std::out_of_range& e) {
82417       {
82418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82419       };
82420     } catch (std::exception& e) {
82421       {
82422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82423       };
82424     } catch (Dali::DaliException e) {
82425       {
82426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82427       };
82428     } catch (...) {
82429       {
82430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82431       };
82432     }
82433   }
82434
82435   jresult = (void *)result;
82436   return jresult;
82437 }
82438
82439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82440 {
82441   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82442   if( arg1 == nullptr )
82443   {
82444     DALI_LOG_ERROR("VideoView is nullptr!");
82445     return nullptr;
82446   }
82447   void * ret = nullptr;
82448   {
82449     try{
82450
82451       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82452       ret = Dali::AnyCast< void * >( result );
82453
82454     } catch (std::out_of_range& e) {
82455       {
82456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82457       };
82458     } catch (std::exception& e) {
82459       {
82460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82461       };
82462     } catch (Dali::DaliException e) {
82463       {
82464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82465       };
82466     } catch (...) {
82467       {
82468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82469       };
82470     }
82471   }
82472   return ret;
82473 }
82474
82475
82476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82477   int jresult ;
82478   int result;
82479
82480   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82481   jresult = (int)result;
82482   return jresult;
82483 }
82484
82485
82486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82487   int jresult ;
82488   int result;
82489
82490   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82491   jresult = (int)result;
82492   return jresult;
82493 }
82494
82495
82496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82497   int jresult ;
82498   int result;
82499
82500   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82501   jresult = (int)result;
82502   return jresult;
82503 }
82504
82505
82506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82507   int jresult ;
82508   int result;
82509
82510   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82511   jresult = (int)result;
82512   return jresult;
82513 }
82514
82515
82516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82517   int jresult ;
82518   int result;
82519
82520   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82521   jresult = (int)result;
82522   return jresult;
82523 }
82524
82525
82526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82527   int jresult ;
82528   int result;
82529
82530   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82531   jresult = (int)result;
82532   return jresult;
82533 }
82534
82535
82536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82537   int jresult ;
82538   int result;
82539
82540   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82541   jresult = (int)result;
82542   return jresult;
82543 }
82544
82545
82546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82547   int jresult ;
82548   int result;
82549
82550   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82551   jresult = (int)result;
82552   return jresult;
82553 }
82554
82555
82556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82557   int jresult ;
82558   int result;
82559
82560   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82561   jresult = (int)result;
82562   return jresult;
82563 }
82564
82565
82566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82567   int jresult ;
82568   int result;
82569
82570   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82571   jresult = (int)result;
82572   return jresult;
82573 }
82574
82575
82576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82577   int jresult ;
82578   int result;
82579
82580   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82581   jresult = (int)result;
82582   return jresult;
82583 }
82584
82585
82586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82587   int jresult ;
82588   int result;
82589
82590   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82591   jresult = (int)result;
82592   return jresult;
82593 }
82594
82595
82596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82597   int jresult ;
82598   int result;
82599
82600   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82601   jresult = (int)result;
82602   return jresult;
82603 }
82604
82605
82606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82607   int jresult ;
82608   int result;
82609
82610   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82611   jresult = (int)result;
82612   return jresult;
82613 }
82614
82615
82616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82617   int jresult ;
82618   int result;
82619
82620   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82621   jresult = (int)result;
82622   return jresult;
82623 }
82624
82625
82626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82627   int jresult ;
82628   int result;
82629
82630   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82631   jresult = (int)result;
82632   return jresult;
82633 }
82634
82635
82636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82637   int jresult ;
82638   int result;
82639
82640   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82641   jresult = (int)result;
82642   return jresult;
82643 }
82644
82645
82646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82647   int jresult ;
82648   int result;
82649
82650   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82651   jresult = (int)result;
82652   return jresult;
82653 }
82654
82655
82656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82657   int jresult ;
82658   int result;
82659
82660   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82661   jresult = (int)result;
82662   return jresult;
82663 }
82664
82665
82666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82667   int jresult ;
82668   int result;
82669
82670   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82671   jresult = (int)result;
82672   return jresult;
82673 }
82674
82675
82676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82677   int jresult ;
82678   int result;
82679
82680   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82681   jresult = (int)result;
82682   return jresult;
82683 }
82684
82685
82686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82687   void * jresult ;
82688   Dali::Toolkit::Popup::Property *result = 0 ;
82689
82690   {
82691     try {
82692       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82693     } catch (std::out_of_range& e) {
82694       {
82695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82696       };
82697     } catch (std::exception& e) {
82698       {
82699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82700       };
82701     } catch (Dali::DaliException e) {
82702       {
82703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82704       };
82705     } catch (...) {
82706       {
82707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82708       };
82709     }
82710   }
82711
82712   jresult = (void *)result;
82713   return jresult;
82714 }
82715
82716
82717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82718   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82719
82720   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82721   {
82722     try {
82723       delete arg1;
82724     } catch (std::out_of_range& e) {
82725       {
82726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82727       };
82728     } catch (std::exception& e) {
82729       {
82730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82731       };
82732     } catch (Dali::DaliException e) {
82733       {
82734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82735       };
82736     } catch (...) {
82737       {
82738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82739       };
82740     }
82741   }
82742
82743 }
82744
82745
82746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82747   void * jresult ;
82748   Dali::Toolkit::Popup *result = 0 ;
82749
82750   {
82751     try {
82752       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82753     } catch (std::out_of_range& e) {
82754       {
82755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82756       };
82757     } catch (std::exception& e) {
82758       {
82759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82760       };
82761     } catch (Dali::DaliException e) {
82762       {
82763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82764       };
82765     } catch (...) {
82766       {
82767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82768       };
82769     }
82770   }
82771
82772   jresult = (void *)result;
82773   return jresult;
82774 }
82775
82776
82777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82778   void * jresult ;
82779   Dali::Toolkit::Popup result;
82780
82781   {
82782     try {
82783       result = Dali::Toolkit::Popup::New();
82784     } catch (std::out_of_range& e) {
82785       {
82786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82787       };
82788     } catch (std::exception& e) {
82789       {
82790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82791       };
82792     } catch (Dali::DaliException e) {
82793       {
82794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82795       };
82796     } catch (...) {
82797       {
82798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82799       };
82800     }
82801   }
82802
82803   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82804   return jresult;
82805 }
82806
82807
82808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82809   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82810
82811   arg1 = (Dali::Toolkit::Popup *)jarg1;
82812   {
82813     try {
82814       delete arg1;
82815     } catch (std::out_of_range& e) {
82816       {
82817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82818       };
82819     } catch (std::exception& e) {
82820       {
82821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82822       };
82823     } catch (Dali::DaliException e) {
82824       {
82825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82826       };
82827     } catch (...) {
82828       {
82829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82830       };
82831     }
82832   }
82833
82834 }
82835
82836
82837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82838   void * jresult ;
82839   Dali::Toolkit::Popup *arg1 = 0 ;
82840   Dali::Toolkit::Popup *result = 0 ;
82841
82842   arg1 = (Dali::Toolkit::Popup *)jarg1;
82843   if (!arg1) {
82844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82845     return 0;
82846   }
82847   {
82848     try {
82849       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82850     } catch (std::out_of_range& e) {
82851       {
82852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82853       };
82854     } catch (std::exception& e) {
82855       {
82856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82857       };
82858     } catch (Dali::DaliException e) {
82859       {
82860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82861       };
82862     } catch (...) {
82863       {
82864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82865       };
82866     }
82867   }
82868
82869   jresult = (void *)result;
82870   return jresult;
82871 }
82872
82873
82874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82875   void * jresult ;
82876   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82877   Dali::Toolkit::Popup *arg2 = 0 ;
82878   Dali::Toolkit::Popup *result = 0 ;
82879
82880   arg1 = (Dali::Toolkit::Popup *)jarg1;
82881   arg2 = (Dali::Toolkit::Popup *)jarg2;
82882   if (!arg2) {
82883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82884     return 0;
82885   }
82886   {
82887     try {
82888       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82889     } catch (std::out_of_range& e) {
82890       {
82891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82892       };
82893     } catch (std::exception& e) {
82894       {
82895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82896       };
82897     } catch (Dali::DaliException e) {
82898       {
82899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82900       };
82901     } catch (...) {
82902       {
82903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82904       };
82905     }
82906   }
82907
82908   jresult = (void *)result;
82909   return jresult;
82910 }
82911
82912
82913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82914   void * jresult ;
82915   Dali::BaseHandle arg1 ;
82916   Dali::BaseHandle *argp1 ;
82917   Dali::Toolkit::Popup result;
82918
82919   argp1 = (Dali::BaseHandle *)jarg1;
82920   if (!argp1) {
82921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82922     return 0;
82923   }
82924   arg1 = *argp1;
82925   {
82926     try {
82927       result = Dali::Toolkit::Popup::DownCast(arg1);
82928     } catch (std::out_of_range& e) {
82929       {
82930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82931       };
82932     } catch (std::exception& e) {
82933       {
82934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82935       };
82936     } catch (Dali::DaliException e) {
82937       {
82938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82939       };
82940     } catch (...) {
82941       {
82942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82943       };
82944     }
82945   }
82946
82947   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82948   return jresult;
82949 }
82950
82951
82952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82953   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82954   Dali::Actor arg2 ;
82955   Dali::Actor *argp2 ;
82956
82957   arg1 = (Dali::Toolkit::Popup *)jarg1;
82958   argp2 = (Dali::Actor *)jarg2;
82959   if (!argp2) {
82960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82961     return ;
82962   }
82963   arg2 = *argp2;
82964   {
82965     try {
82966       (arg1)->SetTitle(arg2);
82967     } catch (std::out_of_range& e) {
82968       {
82969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82970       };
82971     } catch (std::exception& e) {
82972       {
82973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82974       };
82975     } catch (Dali::DaliException e) {
82976       {
82977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82978       };
82979     } catch (...) {
82980       {
82981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82982       };
82983     }
82984   }
82985
82986 }
82987
82988
82989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82990   void * jresult ;
82991   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82992   Dali::Actor result;
82993
82994   arg1 = (Dali::Toolkit::Popup *)jarg1;
82995   {
82996     try {
82997       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82998     } catch (std::out_of_range& e) {
82999       {
83000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83001       };
83002     } catch (std::exception& e) {
83003       {
83004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83005       };
83006     } catch (Dali::DaliException e) {
83007       {
83008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83009       };
83010     } catch (...) {
83011       {
83012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83013       };
83014     }
83015   }
83016
83017   jresult = new Dali::Actor((const Dali::Actor &)result);
83018   return jresult;
83019 }
83020
83021
83022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83023   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83024   Dali::Actor arg2 ;
83025   Dali::Actor *argp2 ;
83026
83027   arg1 = (Dali::Toolkit::Popup *)jarg1;
83028   argp2 = (Dali::Actor *)jarg2;
83029   if (!argp2) {
83030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83031     return ;
83032   }
83033   arg2 = *argp2;
83034   {
83035     try {
83036       (arg1)->SetContent(arg2);
83037     } catch (std::out_of_range& e) {
83038       {
83039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83040       };
83041     } catch (std::exception& e) {
83042       {
83043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83044       };
83045     } catch (Dali::DaliException e) {
83046       {
83047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83048       };
83049     } catch (...) {
83050       {
83051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83052       };
83053     }
83054   }
83055
83056 }
83057
83058
83059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83060   void * jresult ;
83061   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83062   Dali::Actor result;
83063
83064   arg1 = (Dali::Toolkit::Popup *)jarg1;
83065   {
83066     try {
83067       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83068     } catch (std::out_of_range& e) {
83069       {
83070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83071       };
83072     } catch (std::exception& e) {
83073       {
83074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83075       };
83076     } catch (Dali::DaliException e) {
83077       {
83078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83079       };
83080     } catch (...) {
83081       {
83082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83083       };
83084     }
83085   }
83086
83087   jresult = new Dali::Actor((const Dali::Actor &)result);
83088   return jresult;
83089 }
83090
83091
83092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83093   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83094   Dali::Actor arg2 ;
83095   Dali::Actor *argp2 ;
83096
83097   arg1 = (Dali::Toolkit::Popup *)jarg1;
83098   argp2 = (Dali::Actor *)jarg2;
83099   if (!argp2) {
83100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83101     return ;
83102   }
83103   arg2 = *argp2;
83104   {
83105     try {
83106       (arg1)->SetFooter(arg2);
83107     } catch (std::out_of_range& e) {
83108       {
83109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83110       };
83111     } catch (std::exception& e) {
83112       {
83113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83114       };
83115     } catch (Dali::DaliException e) {
83116       {
83117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83118       };
83119     } catch (...) {
83120       {
83121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83122       };
83123     }
83124   }
83125
83126 }
83127
83128
83129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83130   void * jresult ;
83131   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83132   Dali::Actor result;
83133
83134   arg1 = (Dali::Toolkit::Popup *)jarg1;
83135   {
83136     try {
83137       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83138     } catch (std::out_of_range& e) {
83139       {
83140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83141       };
83142     } catch (std::exception& e) {
83143       {
83144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83145       };
83146     } catch (Dali::DaliException e) {
83147       {
83148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83149       };
83150     } catch (...) {
83151       {
83152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83153       };
83154     }
83155   }
83156
83157   jresult = new Dali::Actor((const Dali::Actor &)result);
83158   return jresult;
83159 }
83160
83161
83162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83163   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83164   Dali::Toolkit::Popup::DisplayState arg2 ;
83165
83166   arg1 = (Dali::Toolkit::Popup *)jarg1;
83167   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83168   {
83169     try {
83170       (arg1)->SetDisplayState(arg2);
83171     } catch (std::out_of_range& e) {
83172       {
83173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83174       };
83175     } catch (std::exception& e) {
83176       {
83177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83178       };
83179     } catch (Dali::DaliException e) {
83180       {
83181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83182       };
83183     } catch (...) {
83184       {
83185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83186       };
83187     }
83188   }
83189
83190 }
83191
83192
83193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83194   int jresult ;
83195   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83196   Dali::Toolkit::Popup::DisplayState result;
83197
83198   arg1 = (Dali::Toolkit::Popup *)jarg1;
83199   {
83200     try {
83201       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83202     } catch (std::out_of_range& e) {
83203       {
83204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83205       };
83206     } catch (std::exception& e) {
83207       {
83208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83209       };
83210     } catch (Dali::DaliException e) {
83211       {
83212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83213       };
83214     } catch (...) {
83215       {
83216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83217       };
83218     }
83219   }
83220
83221   jresult = (int)result;
83222   return jresult;
83223 }
83224
83225
83226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83227   void * jresult ;
83228   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83229   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83230
83231   arg1 = (Dali::Toolkit::Popup *)jarg1;
83232   {
83233     try {
83234       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83235     } catch (std::out_of_range& e) {
83236       {
83237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83238       };
83239     } catch (std::exception& e) {
83240       {
83241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83242       };
83243     } catch (Dali::DaliException e) {
83244       {
83245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83246       };
83247     } catch (...) {
83248       {
83249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83250       };
83251     }
83252   }
83253
83254   jresult = (void *)result;
83255   return jresult;
83256 }
83257
83258
83259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83260   void * jresult ;
83261   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83262   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83263
83264   arg1 = (Dali::Toolkit::Popup *)jarg1;
83265   {
83266     try {
83267       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83268     } catch (std::out_of_range& e) {
83269       {
83270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83271       };
83272     } catch (std::exception& e) {
83273       {
83274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83275       };
83276     } catch (Dali::DaliException e) {
83277       {
83278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83279       };
83280     } catch (...) {
83281       {
83282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83283       };
83284     }
83285   }
83286
83287   jresult = (void *)result;
83288   return jresult;
83289 }
83290
83291
83292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83293   void * jresult ;
83294   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83295   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83296
83297   arg1 = (Dali::Toolkit::Popup *)jarg1;
83298   {
83299     try {
83300       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83301     } catch (std::out_of_range& e) {
83302       {
83303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83304       };
83305     } catch (std::exception& e) {
83306       {
83307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83308       };
83309     } catch (Dali::DaliException e) {
83310       {
83311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83312       };
83313     } catch (...) {
83314       {
83315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83316       };
83317     }
83318   }
83319
83320   jresult = (void *)result;
83321   return jresult;
83322 }
83323
83324
83325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83326   void * jresult ;
83327   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83328   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83329
83330   arg1 = (Dali::Toolkit::Popup *)jarg1;
83331   {
83332     try {
83333       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83334     } catch (std::out_of_range& e) {
83335       {
83336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83337       };
83338     } catch (std::exception& e) {
83339       {
83340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83341       };
83342     } catch (Dali::DaliException e) {
83343       {
83344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83345       };
83346     } catch (...) {
83347       {
83348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83349       };
83350     }
83351   }
83352
83353   jresult = (void *)result;
83354   return jresult;
83355 }
83356
83357
83358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83359   void * jresult ;
83360   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83361   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83362
83363   arg1 = (Dali::Toolkit::Popup *)jarg1;
83364   {
83365     try {
83366       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83367     } catch (std::out_of_range& e) {
83368       {
83369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83370       };
83371     } catch (std::exception& e) {
83372       {
83373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83374       };
83375     } catch (Dali::DaliException e) {
83376       {
83377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83378       };
83379     } catch (...) {
83380       {
83381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83382       };
83383     }
83384   }
83385
83386   jresult = (void *)result;
83387   return jresult;
83388 }
83389
83390
83391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83392   int jresult ;
83393   int result;
83394
83395   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83396   jresult = (int)result;
83397   return jresult;
83398 }
83399
83400
83401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83402   int jresult ;
83403   int result;
83404
83405   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83406   jresult = (int)result;
83407   return jresult;
83408 }
83409
83410
83411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83412   int jresult ;
83413   int result;
83414
83415   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83416   jresult = (int)result;
83417   return jresult;
83418 }
83419
83420
83421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83422   int jresult ;
83423   int result;
83424
83425   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83426   jresult = (int)result;
83427   return jresult;
83428 }
83429
83430
83431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83432   int jresult ;
83433   int result;
83434
83435   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83436   jresult = (int)result;
83437   return jresult;
83438 }
83439
83440
83441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83442   int jresult ;
83443   int result;
83444
83445   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83446   jresult = (int)result;
83447   return jresult;
83448 }
83449
83450
83451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83452   int jresult ;
83453   int result;
83454
83455   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83456   jresult = (int)result;
83457   return jresult;
83458 }
83459
83460
83461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83462   int jresult ;
83463   int result;
83464
83465   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83466   jresult = (int)result;
83467   return jresult;
83468 }
83469
83470
83471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83472   int jresult ;
83473   int result;
83474
83475   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83476   jresult = (int)result;
83477   return jresult;
83478 }
83479
83480
83481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83482   void * jresult ;
83483   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83484
83485   {
83486     try {
83487       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83488     } catch (std::out_of_range& e) {
83489       {
83490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83491       };
83492     } catch (std::exception& e) {
83493       {
83494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83495       };
83496     } catch (Dali::DaliException e) {
83497       {
83498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83499       };
83500     } catch (...) {
83501       {
83502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83503       };
83504     }
83505   }
83506
83507   jresult = (void *)result;
83508   return jresult;
83509 }
83510
83511
83512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83513   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83514
83515   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83516   {
83517     try {
83518       delete arg1;
83519     } catch (std::out_of_range& e) {
83520       {
83521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83522       };
83523     } catch (std::exception& e) {
83524       {
83525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83526       };
83527     } catch (Dali::DaliException e) {
83528       {
83529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83530       };
83531     } catch (...) {
83532       {
83533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83534       };
83535     }
83536   }
83537
83538 }
83539
83540
83541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83542   void * jresult ;
83543   Dali::Toolkit::ProgressBar result;
83544
83545   {
83546     try {
83547       result = Dali::Toolkit::ProgressBar::New();
83548     } catch (std::out_of_range& e) {
83549       {
83550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83551       };
83552     } catch (std::exception& e) {
83553       {
83554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83555       };
83556     } catch (Dali::DaliException e) {
83557       {
83558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83559       };
83560     } catch (...) {
83561       {
83562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83563       };
83564     }
83565   }
83566
83567   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83568   return jresult;
83569 }
83570
83571
83572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83573   void * jresult ;
83574   Dali::Toolkit::ProgressBar *result = 0 ;
83575
83576   {
83577     try {
83578       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83579     } catch (std::out_of_range& e) {
83580       {
83581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83582       };
83583     } catch (std::exception& e) {
83584       {
83585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83586       };
83587     } catch (Dali::DaliException e) {
83588       {
83589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83590       };
83591     } catch (...) {
83592       {
83593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83594       };
83595     }
83596   }
83597
83598   jresult = (void *)result;
83599   return jresult;
83600 }
83601
83602
83603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83604   void * jresult ;
83605   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83606   Dali::Toolkit::ProgressBar *result = 0 ;
83607
83608   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83609   if (!arg1) {
83610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83611     return 0;
83612   }
83613   {
83614     try {
83615       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83616     } catch (std::out_of_range& e) {
83617       {
83618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83619       };
83620     } catch (std::exception& e) {
83621       {
83622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83623       };
83624     } catch (Dali::DaliException e) {
83625       {
83626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83627       };
83628     } catch (...) {
83629       {
83630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83631       };
83632     }
83633   }
83634
83635   jresult = (void *)result;
83636   return jresult;
83637 }
83638
83639
83640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83641   void * jresult ;
83642   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83643   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83644   Dali::Toolkit::ProgressBar *result = 0 ;
83645
83646   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83647   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83648   if (!arg2) {
83649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83650     return 0;
83651   }
83652   {
83653     try {
83654       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83655     } catch (std::out_of_range& e) {
83656       {
83657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83658       };
83659     } catch (std::exception& e) {
83660       {
83661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83662       };
83663     } catch (Dali::DaliException e) {
83664       {
83665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83666       };
83667     } catch (...) {
83668       {
83669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83670       };
83671     }
83672   }
83673
83674   jresult = (void *)result;
83675   return jresult;
83676 }
83677
83678
83679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83680   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83681
83682   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83683   {
83684     try {
83685       delete arg1;
83686     } catch (std::out_of_range& e) {
83687       {
83688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83689       };
83690     } catch (std::exception& e) {
83691       {
83692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83693       };
83694     } catch (Dali::DaliException e) {
83695       {
83696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83697       };
83698     } catch (...) {
83699       {
83700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83701       };
83702     }
83703   }
83704
83705 }
83706
83707
83708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83709   void * jresult ;
83710   Dali::BaseHandle arg1 ;
83711   Dali::BaseHandle *argp1 ;
83712   Dali::Toolkit::ProgressBar result;
83713
83714   argp1 = (Dali::BaseHandle *)jarg1;
83715   if (!argp1) {
83716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83717     return 0;
83718   }
83719   arg1 = *argp1;
83720   {
83721     try {
83722       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83723     } catch (std::out_of_range& e) {
83724       {
83725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83726       };
83727     } catch (std::exception& e) {
83728       {
83729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83730       };
83731     } catch (Dali::DaliException e) {
83732       {
83733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83734       };
83735     } catch (...) {
83736       {
83737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83738       };
83739     }
83740   }
83741
83742   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83743   return jresult;
83744 }
83745
83746
83747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83748   void * jresult ;
83749   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83750   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83751
83752   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83753   {
83754     try {
83755       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83756     } catch (std::out_of_range& e) {
83757       {
83758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83759       };
83760     } catch (std::exception& e) {
83761       {
83762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83763       };
83764     } catch (Dali::DaliException e) {
83765       {
83766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83767       };
83768     } catch (...) {
83769       {
83770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83771       };
83772     }
83773   }
83774
83775   jresult = (void *)result;
83776   return jresult;
83777 }
83778
83779
83780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83781   void * jresult ;
83782   Dali::Toolkit::GaussianBlurView *result = 0 ;
83783
83784   {
83785     try {
83786       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83787     } catch (std::out_of_range& e) {
83788       {
83789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83790       };
83791     } catch (std::exception& e) {
83792       {
83793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83794       };
83795     } catch (Dali::DaliException e) {
83796       {
83797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83798       };
83799     } catch (...) {
83800       {
83801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83802       };
83803     }
83804   }
83805
83806   jresult = (void *)result;
83807   return jresult;
83808 }
83809
83810
83811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83812   void * jresult ;
83813   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83814   Dali::Toolkit::GaussianBlurView *result = 0 ;
83815
83816   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83817   if (!arg1) {
83818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83819     return 0;
83820   }
83821   {
83822     try {
83823       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83824     } catch (std::out_of_range& e) {
83825       {
83826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83827       };
83828     } catch (std::exception& e) {
83829       {
83830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83831       };
83832     } catch (Dali::DaliException e) {
83833       {
83834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83835       };
83836     } catch (...) {
83837       {
83838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83839       };
83840     }
83841   }
83842
83843   jresult = (void *)result;
83844   return jresult;
83845 }
83846
83847
83848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83849   void * jresult ;
83850   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83851   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83852   Dali::Toolkit::GaussianBlurView *result = 0 ;
83853
83854   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83855   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83856   if (!arg2) {
83857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83858     return 0;
83859   }
83860   {
83861     try {
83862       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83863     } catch (std::out_of_range& e) {
83864       {
83865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83866       };
83867     } catch (std::exception& e) {
83868       {
83869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83870       };
83871     } catch (Dali::DaliException e) {
83872       {
83873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83874       };
83875     } catch (...) {
83876       {
83877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83878       };
83879     }
83880   }
83881
83882   jresult = (void *)result;
83883   return jresult;
83884 }
83885
83886
83887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83888   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83889
83890   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83891   {
83892     try {
83893       delete arg1;
83894     } catch (std::out_of_range& e) {
83895       {
83896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83897       };
83898     } catch (std::exception& e) {
83899       {
83900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83901       };
83902     } catch (Dali::DaliException e) {
83903       {
83904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83905       };
83906     } catch (...) {
83907       {
83908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83909       };
83910     }
83911   }
83912
83913 }
83914
83915
83916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83917   void * jresult ;
83918   Dali::BaseHandle arg1 ;
83919   Dali::BaseHandle *argp1 ;
83920   Dali::Toolkit::GaussianBlurView result;
83921
83922   argp1 = (Dali::BaseHandle *)jarg1;
83923   if (!argp1) {
83924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83925     return 0;
83926   }
83927   arg1 = *argp1;
83928   {
83929     try {
83930       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83931     } catch (std::out_of_range& e) {
83932       {
83933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83934       };
83935     } catch (std::exception& e) {
83936       {
83937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83938       };
83939     } catch (Dali::DaliException e) {
83940       {
83941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83942       };
83943     } catch (...) {
83944       {
83945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83946       };
83947     }
83948   }
83949
83950   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83951   return jresult;
83952 }
83953
83954
83955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83956   void * jresult ;
83957   Dali::Toolkit::GaussianBlurView result;
83958
83959   {
83960     try {
83961       result = Dali::Toolkit::GaussianBlurView::New();
83962     } catch (std::out_of_range& e) {
83963       {
83964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83965       };
83966     } catch (std::exception& e) {
83967       {
83968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83969       };
83970     } catch (Dali::DaliException e) {
83971       {
83972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83973       };
83974     } catch (...) {
83975       {
83976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83977       };
83978     }
83979   }
83980
83981   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83982   return jresult;
83983 }
83984
83985
83986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83987   void * jresult ;
83988   unsigned int arg1 ;
83989   float arg2 ;
83990   Dali::Pixel::Format arg3 ;
83991   float arg4 ;
83992   float arg5 ;
83993   bool arg6 ;
83994   Dali::Toolkit::GaussianBlurView result;
83995
83996   arg1 = (unsigned int)jarg1;
83997   arg2 = (float)jarg2;
83998   arg3 = (Dali::Pixel::Format)jarg3;
83999   arg4 = (float)jarg4;
84000   arg5 = (float)jarg5;
84001   arg6 = jarg6 ? true : false;
84002   {
84003     try {
84004       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
84005     } catch (std::out_of_range& e) {
84006       {
84007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84008       };
84009     } catch (std::exception& e) {
84010       {
84011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84012       };
84013     } catch (Dali::DaliException e) {
84014       {
84015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84016       };
84017     } catch (...) {
84018       {
84019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84020       };
84021     }
84022   }
84023
84024   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84025   return jresult;
84026 }
84027
84028
84029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84030   void * jresult ;
84031   unsigned int arg1 ;
84032   float arg2 ;
84033   Dali::Pixel::Format arg3 ;
84034   float arg4 ;
84035   float arg5 ;
84036   Dali::Toolkit::GaussianBlurView result;
84037
84038   arg1 = (unsigned int)jarg1;
84039   arg2 = (float)jarg2;
84040   arg3 = (Dali::Pixel::Format)jarg3;
84041   arg4 = (float)jarg4;
84042   arg5 = (float)jarg5;
84043   {
84044     try {
84045       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84046     } catch (std::out_of_range& e) {
84047       {
84048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84049       };
84050     } catch (std::exception& e) {
84051       {
84052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84053       };
84054     } catch (Dali::DaliException e) {
84055       {
84056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84057       };
84058     } catch (...) {
84059       {
84060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84061       };
84062     }
84063   }
84064
84065   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84066   return jresult;
84067 }
84068
84069
84070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84071   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84072   Dali::Actor arg2 ;
84073   Dali::Actor *argp2 ;
84074
84075   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84076   argp2 = (Dali::Actor *)jarg2;
84077   if (!argp2) {
84078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84079     return ;
84080   }
84081   arg2 = *argp2;
84082   {
84083     try {
84084       (arg1)->Add(arg2);
84085     } catch (std::out_of_range& e) {
84086       {
84087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84088       };
84089     } catch (std::exception& e) {
84090       {
84091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84092       };
84093     } catch (Dali::DaliException e) {
84094       {
84095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84096       };
84097     } catch (...) {
84098       {
84099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84100       };
84101     }
84102   }
84103
84104 }
84105
84106
84107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84108   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84109   Dali::Actor arg2 ;
84110   Dali::Actor *argp2 ;
84111
84112   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84113   argp2 = (Dali::Actor *)jarg2;
84114   if (!argp2) {
84115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84116     return ;
84117   }
84118   arg2 = *argp2;
84119   {
84120     try {
84121       (arg1)->Remove(arg2);
84122     } catch (std::out_of_range& e) {
84123       {
84124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84125       };
84126     } catch (std::exception& e) {
84127       {
84128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84129       };
84130     } catch (Dali::DaliException e) {
84131       {
84132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84133       };
84134     } catch (...) {
84135       {
84136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84137       };
84138     }
84139   }
84140
84141 }
84142
84143
84144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84145   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84146
84147   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84148   {
84149     try {
84150       (arg1)->Activate();
84151     } catch (std::out_of_range& e) {
84152       {
84153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84154       };
84155     } catch (std::exception& e) {
84156       {
84157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84158       };
84159     } catch (Dali::DaliException e) {
84160       {
84161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84162       };
84163     } catch (...) {
84164       {
84165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84166       };
84167     }
84168   }
84169
84170 }
84171
84172
84173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84174   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84175
84176   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84177   {
84178     try {
84179       (arg1)->ActivateOnce();
84180     } catch (std::out_of_range& e) {
84181       {
84182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84183       };
84184     } catch (std::exception& e) {
84185       {
84186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84187       };
84188     } catch (Dali::DaliException e) {
84189       {
84190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84191       };
84192     } catch (...) {
84193       {
84194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84195       };
84196     }
84197   }
84198
84199 }
84200
84201
84202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84203   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84204
84205   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84206   {
84207     try {
84208       (arg1)->Deactivate();
84209     } catch (std::out_of_range& e) {
84210       {
84211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84212       };
84213     } catch (std::exception& e) {
84214       {
84215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84216       };
84217     } catch (Dali::DaliException e) {
84218       {
84219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84220       };
84221     } catch (...) {
84222       {
84223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84224       };
84225     }
84226   }
84227
84228 }
84229
84230
84231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84232   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84233   Dali::Texture arg2 ;
84234   Dali::FrameBuffer arg3 ;
84235   Dali::Texture *argp2 ;
84236   Dali::FrameBuffer *argp3 ;
84237
84238   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84239   argp2 = (Dali::Texture *)jarg2;
84240   if (!argp2) {
84241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84242     return ;
84243   }
84244   arg2 = *argp2;
84245   argp3 = (Dali::FrameBuffer *)jarg3;
84246   if (!argp3) {
84247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84248     return ;
84249   }
84250   arg3 = *argp3;
84251   {
84252     try {
84253       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84254     } catch (std::out_of_range& e) {
84255       {
84256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84257       };
84258     } catch (std::exception& e) {
84259       {
84260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84261       };
84262     } catch (Dali::DaliException e) {
84263       {
84264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84265       };
84266     } catch (...) {
84267       {
84268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84269       };
84270     }
84271   }
84272
84273 }
84274
84275
84276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84277   int jresult ;
84278   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84279   Dali::Property::Index result;
84280
84281   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84282   {
84283     try {
84284       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84285     } catch (std::out_of_range& e) {
84286       {
84287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84288       };
84289     } catch (std::exception& e) {
84290       {
84291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84292       };
84293     } catch (Dali::DaliException e) {
84294       {
84295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84296       };
84297     } catch (...) {
84298       {
84299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84300       };
84301     }
84302   }
84303
84304   jresult = result;
84305   return jresult;
84306 }
84307
84308
84309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84310   void * jresult ;
84311   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84312   Dali::FrameBuffer result;
84313
84314   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84315   {
84316     try {
84317       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84318     } catch (std::out_of_range& e) {
84319       {
84320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84321       };
84322     } catch (std::exception& e) {
84323       {
84324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84325       };
84326     } catch (Dali::DaliException e) {
84327       {
84328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84329       };
84330     } catch (...) {
84331       {
84332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84333       };
84334     }
84335   }
84336
84337   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84338   return jresult;
84339 }
84340
84341
84342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84343   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84344   Dali::Vector4 *arg2 = 0 ;
84345
84346   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84347   arg2 = (Dali::Vector4 *)jarg2;
84348   if (!arg2) {
84349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84350     return ;
84351   }
84352   {
84353     try {
84354       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84355     } catch (std::out_of_range& e) {
84356       {
84357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84358       };
84359     } catch (std::exception& e) {
84360       {
84361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84362       };
84363     } catch (Dali::DaliException e) {
84364       {
84365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84366       };
84367     } catch (...) {
84368       {
84369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84370       };
84371     }
84372   }
84373
84374 }
84375
84376
84377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84378   void * jresult ;
84379   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84380   Dali::Vector4 result;
84381
84382   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84383   {
84384     try {
84385       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84386     } catch (std::out_of_range& e) {
84387       {
84388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (std::exception& e) {
84391       {
84392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84393       };
84394     } catch (Dali::DaliException e) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84397       };
84398     } catch (...) {
84399       {
84400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84401       };
84402     }
84403   }
84404
84405   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84406   return jresult;
84407 }
84408
84409
84410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84411   void * jresult ;
84412   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84413   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84414
84415   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84416   {
84417     try {
84418       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84419     } catch (std::out_of_range& e) {
84420       {
84421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84422       };
84423     } catch (std::exception& e) {
84424       {
84425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84426       };
84427     } catch (Dali::DaliException e) {
84428       {
84429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84430       };
84431     } catch (...) {
84432       {
84433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84434       };
84435     }
84436   }
84437
84438   jresult = (void *)result;
84439   return jresult;
84440 }
84441
84442
84443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84444   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84445
84446   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84447   {
84448     try {
84449       delete arg1;
84450     } catch (std::out_of_range& e) {
84451       {
84452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84453       };
84454     } catch (std::exception& e) {
84455       {
84456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84457       };
84458     } catch (Dali::DaliException e) {
84459       {
84460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84461       };
84462     } catch (...) {
84463       {
84464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84465       };
84466     }
84467   }
84468
84469 }
84470
84471
84472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84473   unsigned int jresult ;
84474   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84475   unsigned int result;
84476
84477   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84478   {
84479     try {
84480       result = (unsigned int)(arg1)->GetNumberOfPages();
84481     } catch (std::out_of_range& e) {
84482       {
84483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84484       };
84485     } catch (std::exception& e) {
84486       {
84487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84488       };
84489     } catch (Dali::DaliException e) {
84490       {
84491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84492       };
84493     } catch (...) {
84494       {
84495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84496       };
84497     }
84498   }
84499
84500   jresult = result;
84501   return jresult;
84502 }
84503
84504
84505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84506   void * jresult ;
84507   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84508   unsigned int arg2 ;
84509   Dali::Texture result;
84510
84511   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84512   arg2 = (unsigned int)jarg2;
84513   {
84514     try {
84515       result = (arg1)->NewPage(arg2);
84516     } catch (std::out_of_range& e) {
84517       {
84518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84519       };
84520     } catch (std::exception& e) {
84521       {
84522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84523       };
84524     } catch (Dali::DaliException e) {
84525       {
84526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84527       };
84528     } catch (...) {
84529       {
84530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84531       };
84532     }
84533   }
84534
84535   jresult = new Dali::Texture((const Dali::Texture &)result);
84536   return jresult;
84537 }
84538
84539
84540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84541   int jresult ;
84542   int result;
84543
84544   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84545   jresult = (int)result;
84546   return jresult;
84547 }
84548
84549
84550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84551   int jresult ;
84552   int result;
84553
84554   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84555   jresult = (int)result;
84556   return jresult;
84557 }
84558
84559
84560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84561   int jresult ;
84562   int result;
84563
84564   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84565   jresult = (int)result;
84566   return jresult;
84567 }
84568
84569
84570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84571   void * jresult ;
84572   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84573
84574   {
84575     try {
84576       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84577     } catch (std::out_of_range& e) {
84578       {
84579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84580       };
84581     } catch (std::exception& e) {
84582       {
84583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84584       };
84585     } catch (Dali::DaliException e) {
84586       {
84587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84588       };
84589     } catch (...) {
84590       {
84591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84592       };
84593     }
84594   }
84595
84596   jresult = (void *)result;
84597   return jresult;
84598 }
84599
84600
84601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84602   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84603
84604   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84605   {
84606     try {
84607       delete arg1;
84608     } catch (std::out_of_range& e) {
84609       {
84610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84611       };
84612     } catch (std::exception& e) {
84613       {
84614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84615       };
84616     } catch (Dali::DaliException e) {
84617       {
84618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84619       };
84620     } catch (...) {
84621       {
84622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84623       };
84624     }
84625   }
84626
84627 }
84628
84629
84630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84631   void * jresult ;
84632   Dali::Toolkit::PageTurnView *result = 0 ;
84633
84634   {
84635     try {
84636       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84637     } catch (std::out_of_range& e) {
84638       {
84639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84640       };
84641     } catch (std::exception& e) {
84642       {
84643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84644       };
84645     } catch (Dali::DaliException e) {
84646       {
84647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84648       };
84649     } catch (...) {
84650       {
84651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84652       };
84653     }
84654   }
84655
84656   jresult = (void *)result;
84657   return jresult;
84658 }
84659
84660
84661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84662   void * jresult ;
84663   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84664   Dali::Toolkit::PageTurnView *result = 0 ;
84665
84666   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84667   if (!arg1) {
84668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84669     return 0;
84670   }
84671   {
84672     try {
84673       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84674     } catch (std::out_of_range& e) {
84675       {
84676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84677       };
84678     } catch (std::exception& e) {
84679       {
84680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84681       };
84682     } catch (Dali::DaliException e) {
84683       {
84684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84685       };
84686     } catch (...) {
84687       {
84688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84689       };
84690     }
84691   }
84692
84693   jresult = (void *)result;
84694   return jresult;
84695 }
84696
84697
84698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84699   void * jresult ;
84700   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84701   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84702   Dali::Toolkit::PageTurnView *result = 0 ;
84703
84704   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84705   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84706   if (!arg2) {
84707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84708     return 0;
84709   }
84710   {
84711     try {
84712       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84713     } catch (std::out_of_range& e) {
84714       {
84715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84716       };
84717     } catch (std::exception& e) {
84718       {
84719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84720       };
84721     } catch (Dali::DaliException e) {
84722       {
84723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84724       };
84725     } catch (...) {
84726       {
84727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84728       };
84729     }
84730   }
84731
84732   jresult = (void *)result;
84733   return jresult;
84734 }
84735
84736
84737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84738   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84739
84740   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84741   {
84742     try {
84743       delete arg1;
84744     } catch (std::out_of_range& e) {
84745       {
84746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84747       };
84748     } catch (std::exception& e) {
84749       {
84750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84751       };
84752     } catch (Dali::DaliException e) {
84753       {
84754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84755       };
84756     } catch (...) {
84757       {
84758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84759       };
84760     }
84761   }
84762
84763 }
84764
84765
84766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84767   void * jresult ;
84768   Dali::BaseHandle arg1 ;
84769   Dali::BaseHandle *argp1 ;
84770   Dali::Toolkit::PageTurnView result;
84771
84772   argp1 = (Dali::BaseHandle *)jarg1;
84773   if (!argp1) {
84774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84775     return 0;
84776   }
84777   arg1 = *argp1;
84778   {
84779     try {
84780       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84781     } catch (std::out_of_range& e) {
84782       {
84783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84784       };
84785     } catch (std::exception& e) {
84786       {
84787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84788       };
84789     } catch (Dali::DaliException e) {
84790       {
84791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84792       };
84793     } catch (...) {
84794       {
84795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84796       };
84797     }
84798   }
84799
84800   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84801   return jresult;
84802 }
84803
84804
84805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84806   void * jresult ;
84807   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84808   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84809
84810   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84811   {
84812     try {
84813       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84814     } catch (std::out_of_range& e) {
84815       {
84816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84817       };
84818     } catch (std::exception& e) {
84819       {
84820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84821       };
84822     } catch (Dali::DaliException e) {
84823       {
84824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84825       };
84826     } catch (...) {
84827       {
84828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84829       };
84830     }
84831   }
84832
84833   jresult = (void *)result;
84834   return jresult;
84835 }
84836
84837
84838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84839   void * jresult ;
84840   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84841   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84842
84843   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84844   {
84845     try {
84846       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84847     } catch (std::out_of_range& e) {
84848       {
84849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84850       };
84851     } catch (std::exception& e) {
84852       {
84853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84854       };
84855     } catch (Dali::DaliException e) {
84856       {
84857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84858       };
84859     } catch (...) {
84860       {
84861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84862       };
84863     }
84864   }
84865
84866   jresult = (void *)result;
84867   return jresult;
84868 }
84869
84870
84871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84872   void * jresult ;
84873   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84874   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84875
84876   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84877   {
84878     try {
84879       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84880     } catch (std::out_of_range& e) {
84881       {
84882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84883       };
84884     } catch (std::exception& e) {
84885       {
84886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84887       };
84888     } catch (Dali::DaliException e) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84891       };
84892     } catch (...) {
84893       {
84894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84895       };
84896     }
84897   }
84898
84899   jresult = (void *)result;
84900   return jresult;
84901 }
84902
84903
84904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84905   void * jresult ;
84906   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84907   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84908
84909   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84910   {
84911     try {
84912       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84913     } catch (std::out_of_range& e) {
84914       {
84915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84916       };
84917     } catch (std::exception& e) {
84918       {
84919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84920       };
84921     } catch (Dali::DaliException e) {
84922       {
84923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84924       };
84925     } catch (...) {
84926       {
84927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84928       };
84929     }
84930   }
84931
84932   jresult = (void *)result;
84933   return jresult;
84934 }
84935
84936
84937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84938   void * jresult ;
84939   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84940
84941   {
84942     try {
84943       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84944     } catch (std::out_of_range& e) {
84945       {
84946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84947       };
84948     } catch (std::exception& e) {
84949       {
84950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84951       };
84952     } catch (Dali::DaliException e) {
84953       {
84954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84955       };
84956     } catch (...) {
84957       {
84958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84959       };
84960     }
84961   }
84962
84963   jresult = (void *)result;
84964   return jresult;
84965 }
84966
84967
84968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84969   void * jresult ;
84970   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84971   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84972
84973   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84974   if (!arg1) {
84975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84976     return 0;
84977   }
84978   {
84979     try {
84980       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84981     } catch (std::out_of_range& e) {
84982       {
84983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84984       };
84985     } catch (std::exception& e) {
84986       {
84987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84988       };
84989     } catch (Dali::DaliException e) {
84990       {
84991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84992       };
84993     } catch (...) {
84994       {
84995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84996       };
84997     }
84998   }
84999
85000   jresult = (void *)result;
85001   return jresult;
85002 }
85003
85004
85005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
85006   void * jresult ;
85007   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85008   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
85009   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85010
85011   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85012   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
85013   if (!arg2) {
85014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85015     return 0;
85016   }
85017   {
85018     try {
85019       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
85020     } catch (std::out_of_range& e) {
85021       {
85022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85023       };
85024     } catch (std::exception& e) {
85025       {
85026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85027       };
85028     } catch (Dali::DaliException e) {
85029       {
85030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85031       };
85032     } catch (...) {
85033       {
85034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85035       };
85036     }
85037   }
85038
85039   jresult = (void *)result;
85040   return jresult;
85041 }
85042
85043
85044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
85045   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85046
85047   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85048   {
85049     try {
85050       delete arg1;
85051     } catch (std::out_of_range& e) {
85052       {
85053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85054       };
85055     } catch (std::exception& e) {
85056       {
85057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85058       };
85059     } catch (Dali::DaliException e) {
85060       {
85061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85062       };
85063     } catch (...) {
85064       {
85065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85066       };
85067     }
85068   }
85069
85070 }
85071
85072
85073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
85074   void * jresult ;
85075   Dali::Toolkit::PageFactory *arg1 = 0 ;
85076   Dali::Vector2 *arg2 = 0 ;
85077   Dali::Toolkit::PageTurnLandscapeView result;
85078
85079   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85080   if (!arg1) {
85081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85082     return 0;
85083   }
85084   arg2 = (Dali::Vector2 *)jarg2;
85085   if (!arg2) {
85086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85087     return 0;
85088   }
85089   {
85090     try {
85091       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
85092     } catch (std::out_of_range& e) {
85093       {
85094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85095       };
85096     } catch (std::exception& e) {
85097       {
85098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85099       };
85100     } catch (Dali::DaliException e) {
85101       {
85102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85103       };
85104     } catch (...) {
85105       {
85106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85107       };
85108     }
85109   }
85110
85111   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85112   return jresult;
85113 }
85114
85115
85116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85117   void * jresult ;
85118   Dali::BaseHandle arg1 ;
85119   Dali::BaseHandle *argp1 ;
85120   Dali::Toolkit::PageTurnLandscapeView result;
85121
85122   argp1 = (Dali::BaseHandle *)jarg1;
85123   if (!argp1) {
85124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85125     return 0;
85126   }
85127   arg1 = *argp1;
85128   {
85129     try {
85130       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85131     } catch (std::out_of_range& e) {
85132       {
85133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85134       };
85135     } catch (std::exception& e) {
85136       {
85137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85138       };
85139     } catch (Dali::DaliException e) {
85140       {
85141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85142       };
85143     } catch (...) {
85144       {
85145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85146       };
85147     }
85148   }
85149
85150   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85151   return jresult;
85152 }
85153
85154
85155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85156   void * jresult ;
85157   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85158
85159   {
85160     try {
85161       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85162     } catch (std::out_of_range& e) {
85163       {
85164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85165       };
85166     } catch (std::exception& e) {
85167       {
85168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85169       };
85170     } catch (Dali::DaliException e) {
85171       {
85172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85173       };
85174     } catch (...) {
85175       {
85176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85177       };
85178     }
85179   }
85180
85181   jresult = (void *)result;
85182   return jresult;
85183 }
85184
85185
85186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85187   void * jresult ;
85188   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85189   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85190
85191   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85192   if (!arg1) {
85193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85194     return 0;
85195   }
85196   {
85197     try {
85198       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85199     } catch (std::out_of_range& e) {
85200       {
85201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85202       };
85203     } catch (std::exception& e) {
85204       {
85205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85206       };
85207     } catch (Dali::DaliException e) {
85208       {
85209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85210       };
85211     } catch (...) {
85212       {
85213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85214       };
85215     }
85216   }
85217
85218   jresult = (void *)result;
85219   return jresult;
85220 }
85221
85222
85223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85224   void * jresult ;
85225   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85226   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85227   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85228
85229   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85230   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85231   if (!arg2) {
85232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85233     return 0;
85234   }
85235   {
85236     try {
85237       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85238     } catch (std::out_of_range& e) {
85239       {
85240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85241       };
85242     } catch (std::exception& e) {
85243       {
85244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85245       };
85246     } catch (Dali::DaliException e) {
85247       {
85248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85249       };
85250     } catch (...) {
85251       {
85252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85253       };
85254     }
85255   }
85256
85257   jresult = (void *)result;
85258   return jresult;
85259 }
85260
85261
85262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85263   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85264
85265   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85266   {
85267     try {
85268       delete arg1;
85269     } catch (std::out_of_range& e) {
85270       {
85271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85272       };
85273     } catch (std::exception& e) {
85274       {
85275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85276       };
85277     } catch (Dali::DaliException e) {
85278       {
85279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85280       };
85281     } catch (...) {
85282       {
85283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85284       };
85285     }
85286   }
85287
85288 }
85289
85290
85291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85292   void * jresult ;
85293   Dali::Toolkit::PageFactory *arg1 = 0 ;
85294   Dali::Vector2 *arg2 = 0 ;
85295   Dali::Toolkit::PageTurnPortraitView result;
85296
85297   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85298   if (!arg1) {
85299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85300     return 0;
85301   }
85302   arg2 = (Dali::Vector2 *)jarg2;
85303   if (!arg2) {
85304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85305     return 0;
85306   }
85307   {
85308     try {
85309       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85310     } catch (std::out_of_range& e) {
85311       {
85312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85313       };
85314     } catch (std::exception& e) {
85315       {
85316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85317       };
85318     } catch (Dali::DaliException e) {
85319       {
85320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85321       };
85322     } catch (...) {
85323       {
85324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85325       };
85326     }
85327   }
85328
85329   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85330   return jresult;
85331 }
85332
85333
85334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85335   void * jresult ;
85336   Dali::BaseHandle arg1 ;
85337   Dali::BaseHandle *argp1 ;
85338   Dali::Toolkit::PageTurnPortraitView result;
85339
85340   argp1 = (Dali::BaseHandle *)jarg1;
85341   if (!argp1) {
85342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85343     return 0;
85344   }
85345   arg1 = *argp1;
85346   {
85347     try {
85348       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85349     } catch (std::out_of_range& e) {
85350       {
85351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85352       };
85353     } catch (std::exception& e) {
85354       {
85355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85356       };
85357     } catch (Dali::DaliException e) {
85358       {
85359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85360       };
85361     } catch (...) {
85362       {
85363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85364       };
85365     }
85366   }
85367
85368   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85369   return jresult;
85370 }
85371
85372
85373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85374   int jresult ;
85375   int result;
85376
85377   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85378   jresult = (int)result;
85379   return jresult;
85380 }
85381
85382
85383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85384   int jresult ;
85385   int result;
85386
85387   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85388   jresult = (int)result;
85389   return jresult;
85390 }
85391
85392
85393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85394   int jresult ;
85395   int result;
85396
85397   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85398   jresult = (int)result;
85399   return jresult;
85400 }
85401
85402
85403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85404   void * jresult ;
85405   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85406
85407   {
85408     try {
85409       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85410     } catch (std::out_of_range& e) {
85411       {
85412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85413       };
85414     } catch (std::exception& e) {
85415       {
85416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85417       };
85418     } catch (Dali::DaliException e) {
85419       {
85420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85421       };
85422     } catch (...) {
85423       {
85424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85425       };
85426     }
85427   }
85428
85429   jresult = (void *)result;
85430   return jresult;
85431 }
85432
85433
85434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85435   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85436
85437   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85438   {
85439     try {
85440       delete arg1;
85441     } catch (std::out_of_range& e) {
85442       {
85443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85444       };
85445     } catch (std::exception& e) {
85446       {
85447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85448       };
85449     } catch (Dali::DaliException e) {
85450       {
85451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85452       };
85453     } catch (...) {
85454       {
85455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85456       };
85457     }
85458   }
85459
85460 }
85461
85462
85463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85464   void * jresult ;
85465   Dali::Toolkit::ToggleButton *result = 0 ;
85466
85467   {
85468     try {
85469       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85470     } catch (std::out_of_range& e) {
85471       {
85472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85473       };
85474     } catch (std::exception& e) {
85475       {
85476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85477       };
85478     } catch (Dali::DaliException e) {
85479       {
85480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85481       };
85482     } catch (...) {
85483       {
85484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85485       };
85486     }
85487   }
85488
85489   jresult = (void *)result;
85490   return jresult;
85491 }
85492
85493
85494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85495   void * jresult ;
85496   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85497   Dali::Toolkit::ToggleButton *result = 0 ;
85498
85499   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85500   if (!arg1) {
85501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85502     return 0;
85503   }
85504   {
85505     try {
85506       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85507     } catch (std::out_of_range& e) {
85508       {
85509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85510       };
85511     } catch (std::exception& e) {
85512       {
85513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85514       };
85515     } catch (Dali::DaliException e) {
85516       {
85517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85518       };
85519     } catch (...) {
85520       {
85521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85522       };
85523     }
85524   }
85525
85526   jresult = (void *)result;
85527   return jresult;
85528 }
85529
85530
85531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85532   void * jresult ;
85533   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85534   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85535   Dali::Toolkit::ToggleButton *result = 0 ;
85536
85537   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85538   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85539   if (!arg2) {
85540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85541     return 0;
85542   }
85543   {
85544     try {
85545       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85546     } catch (std::out_of_range& e) {
85547       {
85548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85549       };
85550     } catch (std::exception& e) {
85551       {
85552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85553       };
85554     } catch (Dali::DaliException e) {
85555       {
85556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85557       };
85558     } catch (...) {
85559       {
85560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85561       };
85562     }
85563   }
85564
85565   jresult = (void *)result;
85566   return jresult;
85567 }
85568
85569
85570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85571   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85572
85573   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85574   {
85575     try {
85576       delete arg1;
85577     } catch (std::out_of_range& e) {
85578       {
85579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85580       };
85581     } catch (std::exception& e) {
85582       {
85583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85584       };
85585     } catch (Dali::DaliException e) {
85586       {
85587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85588       };
85589     } catch (...) {
85590       {
85591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85592       };
85593     }
85594   }
85595
85596 }
85597
85598
85599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85600   void * jresult ;
85601   Dali::Toolkit::ToggleButton result;
85602
85603   {
85604     try {
85605       result = Dali::Toolkit::ToggleButton::New();
85606     } catch (std::out_of_range& e) {
85607       {
85608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85609       };
85610     } catch (std::exception& e) {
85611       {
85612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85613       };
85614     } catch (Dali::DaliException e) {
85615       {
85616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85617       };
85618     } catch (...) {
85619       {
85620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85621       };
85622     }
85623   }
85624
85625   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85626   return jresult;
85627 }
85628
85629
85630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85631   void * jresult ;
85632   Dali::BaseHandle arg1 ;
85633   Dali::BaseHandle *argp1 ;
85634   Dali::Toolkit::ToggleButton result;
85635
85636   argp1 = (Dali::BaseHandle *)jarg1;
85637   if (!argp1) {
85638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85639     return 0;
85640   }
85641   arg1 = *argp1;
85642   {
85643     try {
85644       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85645     } catch (std::out_of_range& e) {
85646       {
85647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85648       };
85649     } catch (std::exception& e) {
85650       {
85651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85652       };
85653     } catch (Dali::DaliException e) {
85654       {
85655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85656       };
85657     } catch (...) {
85658       {
85659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85660       };
85661     }
85662   }
85663
85664   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85665   return jresult;
85666 }
85667
85668
85669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85670   void * jresult ;
85671   Dali::Toolkit::Visual::Base *result = 0 ;
85672
85673   {
85674     try {
85675       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85676     } catch (std::out_of_range& e) {
85677       {
85678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85679       };
85680     } catch (std::exception& e) {
85681       {
85682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85683       };
85684     } catch (Dali::DaliException e) {
85685       {
85686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85687       };
85688     } catch (...) {
85689       {
85690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85691       };
85692     }
85693   }
85694
85695   jresult = (void *)result;
85696   return jresult;
85697 }
85698
85699
85700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85701   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85702
85703   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85704   {
85705     try {
85706       delete arg1;
85707     } catch (std::out_of_range& e) {
85708       {
85709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85710       };
85711     } catch (std::exception& e) {
85712       {
85713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85714       };
85715     } catch (Dali::DaliException e) {
85716       {
85717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85718       };
85719     } catch (...) {
85720       {
85721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85722       };
85723     }
85724   }
85725
85726 }
85727
85728
85729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85730   void * jresult ;
85731   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85732   Dali::Toolkit::Visual::Base *result = 0 ;
85733
85734   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85735   if (!arg1) {
85736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85737     return 0;
85738   }
85739   {
85740     try {
85741       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85742     } catch (std::out_of_range& e) {
85743       {
85744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85745       };
85746     } catch (std::exception& e) {
85747       {
85748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85749       };
85750     } catch (Dali::DaliException e) {
85751       {
85752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85753       };
85754     } catch (...) {
85755       {
85756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85757       };
85758     }
85759   }
85760
85761   jresult = (void *)result;
85762   return jresult;
85763 }
85764
85765
85766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85767   void * jresult ;
85768   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85769   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85770   Dali::Toolkit::Visual::Base *result = 0 ;
85771
85772   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85773   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85774   if (!arg2) {
85775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85776     return 0;
85777   }
85778   {
85779     try {
85780       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85781     } catch (std::out_of_range& e) {
85782       {
85783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85784       };
85785     } catch (std::exception& e) {
85786       {
85787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85788       };
85789     } catch (Dali::DaliException e) {
85790       {
85791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85792       };
85793     } catch (...) {
85794       {
85795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85796       };
85797     }
85798   }
85799
85800   jresult = (void *)result;
85801   return jresult;
85802 }
85803
85804
85805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85806   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85807   std::string *arg2 = 0 ;
85808
85809   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85810   if (!jarg2) {
85811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85812     return ;
85813   }
85814   std::string arg2_str(jarg2);
85815   arg2 = &arg2_str;
85816   {
85817     try {
85818       (arg1)->SetName((std::string const &)*arg2);
85819     } catch (std::out_of_range& e) {
85820       {
85821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85822       };
85823     } catch (std::exception& e) {
85824       {
85825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85826       };
85827     } catch (Dali::DaliException e) {
85828       {
85829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85830       };
85831     } catch (...) {
85832       {
85833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85834       };
85835     }
85836   }
85837
85838
85839   //argout typemap for const std::string&
85840
85841 }
85842
85843
85844 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85845   char * jresult ;
85846   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85847   std::string *result = 0 ;
85848
85849   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85850   {
85851     try {
85852       result = (std::string *) &(arg1)->GetName();
85853     } catch (std::out_of_range& e) {
85854       {
85855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85856       };
85857     } catch (std::exception& e) {
85858       {
85859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85860       };
85861     } catch (Dali::DaliException e) {
85862       {
85863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85864       };
85865     } catch (...) {
85866       {
85867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85868       };
85869     }
85870   }
85871
85872   jresult = SWIG_csharp_string_callback(result->c_str());
85873   return jresult;
85874 }
85875
85876
85877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85878   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85879   Dali::Property::Map *arg2 = 0 ;
85880   Dali::Size arg3 ;
85881   Dali::Size *argp3 ;
85882
85883   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85884   arg2 = (Dali::Property::Map *)jarg2;
85885   if (!arg2) {
85886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85887     return ;
85888   }
85889   argp3 = (Dali::Size *)jarg3;
85890   if (!argp3) {
85891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85892     return ;
85893   }
85894   arg3 = *argp3;
85895   {
85896     try {
85897       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85898     } catch (std::out_of_range& e) {
85899       {
85900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85901       };
85902     } catch (std::exception& e) {
85903       {
85904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85905       };
85906     } catch (Dali::DaliException e) {
85907       {
85908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85909       };
85910     } catch (...) {
85911       {
85912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85913       };
85914     }
85915   }
85916
85917 }
85918
85919
85920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85921   float jresult ;
85922   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85923   float arg2 ;
85924   float result;
85925
85926   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85927   arg2 = (float)jarg2;
85928   {
85929     try {
85930       result = (float)(arg1)->GetHeightForWidth(arg2);
85931     } catch (std::out_of_range& e) {
85932       {
85933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85934       };
85935     } catch (std::exception& e) {
85936       {
85937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85938       };
85939     } catch (Dali::DaliException e) {
85940       {
85941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85942       };
85943     } catch (...) {
85944       {
85945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85946       };
85947     }
85948   }
85949
85950   jresult = result;
85951   return jresult;
85952 }
85953
85954
85955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85956   float jresult ;
85957   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85958   float arg2 ;
85959   float result;
85960
85961   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85962   arg2 = (float)jarg2;
85963   {
85964     try {
85965       result = (float)(arg1)->GetWidthForHeight(arg2);
85966     } catch (std::out_of_range& e) {
85967       {
85968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85969       };
85970     } catch (std::exception& e) {
85971       {
85972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85973       };
85974     } catch (Dali::DaliException e) {
85975       {
85976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85977       };
85978     } catch (...) {
85979       {
85980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85981       };
85982     }
85983   }
85984
85985   jresult = result;
85986   return jresult;
85987 }
85988
85989
85990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85991   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85992   Dali::Vector2 *arg2 = 0 ;
85993
85994   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85995   arg2 = (Dali::Vector2 *)jarg2;
85996   if (!arg2) {
85997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85998     return ;
85999   }
86000   {
86001     try {
86002       (arg1)->GetNaturalSize(*arg2);
86003     } catch (std::out_of_range& e) {
86004       {
86005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86006       };
86007     } catch (std::exception& e) {
86008       {
86009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86010       };
86011     } catch (Dali::DaliException e) {
86012       {
86013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86014       };
86015     } catch (...) {
86016       {
86017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86018       };
86019     }
86020   }
86021
86022 }
86023
86024
86025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
86026   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86027   float arg2 ;
86028
86029   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86030   arg2 = (int)jarg2;
86031   {
86032     try {
86033       (arg1)->SetDepthIndex(arg2);
86034     } catch (std::out_of_range& e) {
86035       {
86036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86037       };
86038     } catch (std::exception& e) {
86039       {
86040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86041       };
86042     } catch (Dali::DaliException e) {
86043       {
86044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86045       };
86046     } catch (...) {
86047       {
86048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86049       };
86050     }
86051   }
86052
86053 }
86054
86055
86056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
86057   int jresult ;
86058   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86059   int result;
86060
86061   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86062   {
86063     try {
86064       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
86065     } catch (std::out_of_range& e) {
86066       {
86067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86068       };
86069     } catch (std::exception& e) {
86070       {
86071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86072       };
86073     } catch (Dali::DaliException e) {
86074       {
86075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86076       };
86077     } catch (...) {
86078       {
86079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86080       };
86081     }
86082   }
86083
86084   jresult = result;
86085   return jresult;
86086 }
86087
86088
86089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
86090   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86091   Dali::Property::Map *arg2 = 0 ;
86092
86093   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86094   arg2 = (Dali::Property::Map *)jarg2;
86095   if (!arg2) {
86096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
86097     return ;
86098   }
86099   {
86100     try {
86101       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
86102     } catch (std::out_of_range& e) {
86103       {
86104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86105       };
86106     } catch (std::exception& e) {
86107       {
86108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86109       };
86110     } catch (Dali::DaliException e) {
86111       {
86112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86113       };
86114     } catch (...) {
86115       {
86116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86117       };
86118     }
86119   }
86120
86121 }
86122
86123
86124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
86125   void * jresult ;
86126   Dali::Toolkit::VisualFactory result;
86127
86128   {
86129     try {
86130       result = Dali::Toolkit::VisualFactory::Get();
86131     } catch (std::out_of_range& e) {
86132       {
86133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86134       };
86135     } catch (std::exception& e) {
86136       {
86137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86138       };
86139     } catch (Dali::DaliException e) {
86140       {
86141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86142       };
86143     } catch (...) {
86144       {
86145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86146       };
86147     }
86148   }
86149
86150   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
86151   return jresult;
86152 }
86153
86154
86155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
86156   void * jresult ;
86157   Dali::Toolkit::VisualFactory *result = 0 ;
86158
86159   {
86160     try {
86161       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
86162     } catch (std::out_of_range& e) {
86163       {
86164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86165       };
86166     } catch (std::exception& e) {
86167       {
86168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86169       };
86170     } catch (Dali::DaliException e) {
86171       {
86172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86173       };
86174     } catch (...) {
86175       {
86176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86177       };
86178     }
86179   }
86180
86181   jresult = (void *)result;
86182   return jresult;
86183 }
86184
86185
86186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86187   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86188
86189   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86190   {
86191     try {
86192       delete arg1;
86193     } catch (std::out_of_range& e) {
86194       {
86195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86196       };
86197     } catch (std::exception& e) {
86198       {
86199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86200       };
86201     } catch (Dali::DaliException e) {
86202       {
86203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86204       };
86205     } catch (...) {
86206       {
86207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86208       };
86209     }
86210   }
86211
86212 }
86213
86214
86215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86216   void * jresult ;
86217   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86218   Dali::Toolkit::VisualFactory *result = 0 ;
86219
86220   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86221   if (!arg1) {
86222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86223     return 0;
86224   }
86225   {
86226     try {
86227       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86228     } catch (std::out_of_range& e) {
86229       {
86230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86231       };
86232     } catch (std::exception& e) {
86233       {
86234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86235       };
86236     } catch (Dali::DaliException e) {
86237       {
86238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86239       };
86240     } catch (...) {
86241       {
86242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86243       };
86244     }
86245   }
86246
86247   jresult = (void *)result;
86248   return jresult;
86249 }
86250
86251
86252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86253   void * jresult ;
86254   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86255   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86256   Dali::Toolkit::VisualFactory *result = 0 ;
86257
86258   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86259   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86260   if (!arg2) {
86261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86262     return 0;
86263   }
86264   {
86265     try {
86266       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86267     } catch (std::out_of_range& e) {
86268       {
86269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86270       };
86271     } catch (std::exception& e) {
86272       {
86273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86274       };
86275     } catch (Dali::DaliException e) {
86276       {
86277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86278       };
86279     } catch (...) {
86280       {
86281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86282       };
86283     }
86284   }
86285
86286   jresult = (void *)result;
86287   return jresult;
86288 }
86289
86290
86291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86292   void * jresult ;
86293   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86294   Dali::Property::Map *arg2 = 0 ;
86295   Dali::Toolkit::Visual::Base result;
86296
86297   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86298   arg2 = (Dali::Property::Map *)jarg2;
86299   if (!arg2) {
86300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86301     return 0;
86302   }
86303   {
86304     try {
86305       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86306     } catch (std::out_of_range& e) {
86307       {
86308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86309       };
86310     } catch (std::exception& e) {
86311       {
86312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86313       };
86314     } catch (Dali::DaliException e) {
86315       {
86316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86317       };
86318     } catch (...) {
86319       {
86320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86321       };
86322     }
86323   }
86324
86325   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86326   return jresult;
86327 }
86328
86329
86330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86331   void * jresult ;
86332   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86333   std::string *arg2 = 0 ;
86334   Dali::ImageDimensions arg3 ;
86335   Dali::ImageDimensions *argp3 ;
86336   Dali::Toolkit::Visual::Base result;
86337
86338   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86339   if (!jarg2) {
86340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86341     return 0;
86342   }
86343   std::string arg2_str(jarg2);
86344   arg2 = &arg2_str;
86345   argp3 = (Dali::ImageDimensions *)jarg3;
86346   if (!argp3) {
86347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86348     return 0;
86349   }
86350   arg3 = *argp3;
86351   {
86352     try {
86353       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
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 = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86374
86375   //argout typemap for const std::string&
86376
86377   return jresult;
86378 }
86379
86380
86381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86382   void * jresult ;
86383   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86384
86385   {
86386     try {
86387       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86388     } catch (std::out_of_range& e) {
86389       {
86390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86391       };
86392     } catch (std::exception& e) {
86393       {
86394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86395       };
86396     } catch (Dali::DaliException e) {
86397       {
86398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86399       };
86400     } catch (...) {
86401       {
86402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86403       };
86404     }
86405   }
86406
86407   jresult = (void *)result;
86408   return jresult;
86409 }
86410
86411
86412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86413   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86414
86415   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86416   {
86417     try {
86418       delete arg1;
86419     } catch (std::out_of_range& e) {
86420       {
86421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86422       };
86423     } catch (std::exception& e) {
86424       {
86425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86426       };
86427     } catch (Dali::DaliException e) {
86428       {
86429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86430       };
86431     } catch (...) {
86432       {
86433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86434       };
86435     }
86436   }
86437
86438 }
86439
86440
86441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86442   void * jresult ;
86443   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86444   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86445
86446   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86447   if (!arg1) {
86448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86449     return 0;
86450   }
86451   {
86452     try {
86453       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86454     } catch (std::out_of_range& e) {
86455       {
86456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86457       };
86458     } catch (std::exception& e) {
86459       {
86460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86461       };
86462     } catch (Dali::DaliException e) {
86463       {
86464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86465       };
86466     } catch (...) {
86467       {
86468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86469       };
86470     }
86471   }
86472
86473   jresult = (void *)result;
86474   return jresult;
86475 }
86476
86477
86478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86479   void * jresult ;
86480   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86481   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86482   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86483
86484   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86485   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86486   if (!arg2) {
86487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86488     return 0;
86489   }
86490   {
86491     try {
86492       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86493     } catch (std::out_of_range& e) {
86494       {
86495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86496       };
86497     } catch (std::exception& e) {
86498       {
86499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86500       };
86501     } catch (Dali::DaliException e) {
86502       {
86503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86504       };
86505     } catch (...) {
86506       {
86507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86508       };
86509     }
86510   }
86511
86512   jresult = (void *)result;
86513   return jresult;
86514 }
86515
86516
86517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86518   void * jresult ;
86519   Dali::Toolkit::AsyncImageLoader result;
86520
86521   {
86522     try {
86523       result = Dali::Toolkit::AsyncImageLoader::New();
86524     } catch (std::out_of_range& e) {
86525       {
86526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86527       };
86528     } catch (std::exception& e) {
86529       {
86530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86531       };
86532     } catch (Dali::DaliException e) {
86533       {
86534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86535       };
86536     } catch (...) {
86537       {
86538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86539       };
86540     }
86541   }
86542
86543   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86544   return jresult;
86545 }
86546
86547
86548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86549   void * jresult ;
86550   Dali::BaseHandle arg1 ;
86551   Dali::BaseHandle *argp1 ;
86552   Dali::Toolkit::AsyncImageLoader result;
86553
86554   argp1 = (Dali::BaseHandle *)jarg1;
86555   if (!argp1) {
86556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86557     return 0;
86558   }
86559   arg1 = *argp1;
86560   {
86561     try {
86562       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86563     } catch (std::out_of_range& e) {
86564       {
86565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86566       };
86567     } catch (std::exception& e) {
86568       {
86569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86570       };
86571     } catch (Dali::DaliException e) {
86572       {
86573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86574       };
86575     } catch (...) {
86576       {
86577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86578       };
86579     }
86580   }
86581
86582   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86583   return jresult;
86584 }
86585
86586
86587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86588   unsigned int jresult ;
86589   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86590   std::string *arg2 = 0 ;
86591   uint32_t result;
86592
86593   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86594   if (!jarg2) {
86595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86596     return 0;
86597   }
86598   std::string arg2_str(jarg2);
86599   arg2 = &arg2_str;
86600   {
86601     try {
86602       result = (arg1)->Load((std::string const &)*arg2);
86603     } catch (std::out_of_range& e) {
86604       {
86605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86606       };
86607     } catch (std::exception& e) {
86608       {
86609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86610       };
86611     } catch (Dali::DaliException e) {
86612       {
86613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86614       };
86615     } catch (...) {
86616       {
86617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86618       };
86619     }
86620   }
86621
86622   jresult = result;
86623
86624   //argout typemap for const std::string&
86625
86626   return jresult;
86627 }
86628
86629
86630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86631   unsigned int jresult ;
86632   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86633   std::string *arg2 = 0 ;
86634   Dali::ImageDimensions arg3 ;
86635   Dali::ImageDimensions *argp3 ;
86636   uint32_t result;
86637
86638   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86639   if (!jarg2) {
86640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86641     return 0;
86642   }
86643   std::string arg2_str(jarg2);
86644   arg2 = &arg2_str;
86645   argp3 = (Dali::ImageDimensions *)jarg3;
86646   if (!argp3) {
86647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86648     return 0;
86649   }
86650   arg3 = *argp3;
86651   {
86652     try {
86653       result = (arg1)->Load((std::string const &)*arg2,arg3);
86654     } catch (std::out_of_range& e) {
86655       {
86656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86657       };
86658     } catch (std::exception& e) {
86659       {
86660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86661       };
86662     } catch (Dali::DaliException e) {
86663       {
86664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86665       };
86666     } catch (...) {
86667       {
86668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86669       };
86670     }
86671   }
86672
86673   jresult = result;
86674
86675   //argout typemap for const std::string&
86676
86677   return jresult;
86678 }
86679
86680
86681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86682   unsigned int jresult ;
86683   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86684   std::string *arg2 = 0 ;
86685   Dali::ImageDimensions arg3 ;
86686   Dali::FittingMode::Type arg4 ;
86687   Dali::SamplingMode::Type arg5 ;
86688   bool arg6 ;
86689   Dali::ImageDimensions *argp3 ;
86690   uint32_t result;
86691
86692   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86693   if (!jarg2) {
86694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86695     return 0;
86696   }
86697   std::string arg2_str(jarg2);
86698   arg2 = &arg2_str;
86699   argp3 = (Dali::ImageDimensions *)jarg3;
86700   if (!argp3) {
86701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86702     return 0;
86703   }
86704   arg3 = *argp3;
86705   arg4 = (Dali::FittingMode::Type)jarg4;
86706   arg5 = (Dali::SamplingMode::Type)jarg5;
86707   arg6 = jarg6 ? true : false;
86708   {
86709     try {
86710       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86711     } catch (std::out_of_range& e) {
86712       {
86713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86714       };
86715     } catch (std::exception& e) {
86716       {
86717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86718       };
86719     } catch (Dali::DaliException e) {
86720       {
86721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86722       };
86723     } catch (...) {
86724       {
86725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86726       };
86727     }
86728   }
86729
86730   jresult = result;
86731
86732   //argout typemap for const std::string&
86733
86734   return jresult;
86735 }
86736
86737
86738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86739   unsigned int jresult ;
86740   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86741   uint32_t arg2 ;
86742   bool result;
86743
86744   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86745   arg2 = (uint32_t)jarg2;
86746   {
86747     try {
86748       result = (bool)(arg1)->Cancel(arg2);
86749     } catch (std::out_of_range& e) {
86750       {
86751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86752       };
86753     } catch (std::exception& e) {
86754       {
86755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86756       };
86757     } catch (Dali::DaliException e) {
86758       {
86759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86760       };
86761     } catch (...) {
86762       {
86763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86764       };
86765     }
86766   }
86767
86768   jresult = result;
86769   return jresult;
86770 }
86771
86772
86773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86774   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86775
86776   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86777   {
86778     try {
86779       (arg1)->CancelAll();
86780     } catch (std::out_of_range& e) {
86781       {
86782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86783       };
86784     } catch (std::exception& e) {
86785       {
86786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86787       };
86788     } catch (Dali::DaliException e) {
86789       {
86790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86791       };
86792     } catch (...) {
86793       {
86794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86795       };
86796     }
86797   }
86798
86799 }
86800
86801
86802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86803   void * jresult ;
86804   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86805   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86806
86807   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86808   {
86809     try {
86810       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86811     } catch (std::out_of_range& e) {
86812       {
86813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86814       };
86815     } catch (std::exception& e) {
86816       {
86817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86818       };
86819     } catch (Dali::DaliException e) {
86820       {
86821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86822       };
86823     } catch (...) {
86824       {
86825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86826       };
86827     }
86828   }
86829
86830   jresult = (void *)result;
86831   return jresult;
86832 }
86833
86834
86835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86836   void * jresult ;
86837   std::string *arg1 = 0 ;
86838   Dali::PixelData result;
86839
86840   if (!jarg1) {
86841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86842     return 0;
86843   }
86844   std::string arg1_str(jarg1);
86845   arg1 = &arg1_str;
86846   {
86847     try {
86848       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86849     } catch (std::out_of_range& e) {
86850       {
86851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86852       };
86853     } catch (std::exception& e) {
86854       {
86855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86856       };
86857     } catch (Dali::DaliException e) {
86858       {
86859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86860       };
86861     } catch (...) {
86862       {
86863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86864       };
86865     }
86866   }
86867
86868   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86869
86870   //argout typemap for const std::string&
86871
86872   return jresult;
86873 }
86874
86875
86876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86877   void * jresult ;
86878   std::string *arg1 = 0 ;
86879   Dali::ImageDimensions arg2 ;
86880   Dali::ImageDimensions *argp2 ;
86881   Dali::PixelData result;
86882
86883   if (!jarg1) {
86884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86885     return 0;
86886   }
86887   std::string arg1_str(jarg1);
86888   arg1 = &arg1_str;
86889   argp2 = (Dali::ImageDimensions *)jarg2;
86890   if (!argp2) {
86891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86892     return 0;
86893   }
86894   arg2 = *argp2;
86895   {
86896     try {
86897       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86898     } catch (std::out_of_range& e) {
86899       {
86900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86901       };
86902     } catch (std::exception& e) {
86903       {
86904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86905       };
86906     } catch (Dali::DaliException e) {
86907       {
86908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86909       };
86910     } catch (...) {
86911       {
86912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86913       };
86914     }
86915   }
86916
86917   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86918
86919   //argout typemap for const std::string&
86920
86921   return jresult;
86922 }
86923
86924
86925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86926   void * jresult ;
86927   std::string *arg1 = 0 ;
86928   Dali::ImageDimensions arg2 ;
86929   Dali::FittingMode::Type arg3 ;
86930   Dali::SamplingMode::Type arg4 ;
86931   bool arg5 ;
86932   Dali::ImageDimensions *argp2 ;
86933   Dali::PixelData result;
86934
86935   if (!jarg1) {
86936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86937     return 0;
86938   }
86939   std::string arg1_str(jarg1);
86940   arg1 = &arg1_str;
86941   argp2 = (Dali::ImageDimensions *)jarg2;
86942   if (!argp2) {
86943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86944     return 0;
86945   }
86946   arg2 = *argp2;
86947   arg3 = (Dali::FittingMode::Type)jarg3;
86948   arg4 = (Dali::SamplingMode::Type)jarg4;
86949   arg5 = jarg5 ? true : false;
86950   {
86951     try {
86952       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86953     } catch (std::out_of_range& e) {
86954       {
86955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86956       };
86957     } catch (std::exception& e) {
86958       {
86959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86960       };
86961     } catch (Dali::DaliException e) {
86962       {
86963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86964       };
86965     } catch (...) {
86966       {
86967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86968       };
86969     }
86970   }
86971
86972   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86973
86974   //argout typemap for const std::string&
86975
86976   return jresult;
86977 }
86978
86979
86980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86981   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86982
86983   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86984   {
86985     try {
86986       delete arg1;
86987     } catch (std::out_of_range& e) {
86988       {
86989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86990       };
86991     } catch (std::exception& e) {
86992       {
86993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86994       };
86995     } catch (Dali::DaliException e) {
86996       {
86997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86998       };
86999     } catch (...) {
87000       {
87001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87002       };
87003     }
87004   }
87005
87006 }
87007
87008
87009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
87010   void * jresult ;
87011   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87012   Dali::Actor arg2 ;
87013   Dali::Actor arg3 ;
87014   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
87015   Dali::Actor *argp2 ;
87016   Dali::Actor *argp3 ;
87017   Dali::Actor result;
87018
87019   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87020   argp2 = (Dali::Actor *)jarg2;
87021   if (!argp2) {
87022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87023     return 0;
87024   }
87025   arg2 = *argp2;
87026   argp3 = (Dali::Actor *)jarg3;
87027   if (!argp3) {
87028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87029     return 0;
87030   }
87031   arg3 = *argp3;
87032   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
87033   {
87034     try {
87035       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
87036     } catch (std::out_of_range& e) {
87037       {
87038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87039       };
87040     } catch (std::exception& e) {
87041       {
87042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87043       };
87044     } catch (Dali::DaliException e) {
87045       {
87046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87047       };
87048     } catch (...) {
87049       {
87050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87051       };
87052     }
87053   }
87054
87055   jresult = new Dali::Actor((const Dali::Actor &)result);
87056   return jresult;
87057 }
87058
87059
87060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
87061   void * jresult ;
87062   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
87063
87064   {
87065     try {
87066       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
87067     } catch (std::out_of_range& e) {
87068       {
87069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87070       };
87071     } catch (std::exception& e) {
87072       {
87073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87074       };
87075     } catch (Dali::DaliException e) {
87076       {
87077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87078       };
87079     } catch (...) {
87080       {
87081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87082       };
87083     }
87084   }
87085
87086   jresult = (void *)result;
87087   return jresult;
87088 }
87089
87090
87091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
87092   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
87093   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87094   if (director) {
87095     director->swig_connect_director(callback0);
87096   }
87097 }
87098
87099
87100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
87101   void * jresult ;
87102   Dali::FrameCallbackInterface *result = 0 ;
87103
87104   {
87105     try {
87106       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
87107     } catch (std::out_of_range& e) {
87108       {
87109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87110       };
87111     } catch (std::exception& e) {
87112       {
87113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87114       };
87115     } catch (Dali::DaliException e) {
87116       {
87117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87118       };
87119     } catch (...) {
87120       {
87121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87122       };
87123     }
87124   }
87125
87126   jresult = (void *)result;
87127   return jresult;
87128 }
87129
87130 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
87131   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87132   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87133   return proxy->GetPosition(id, *vector3);
87134 }
87135
87136 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
87137   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87138   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87139   return proxy->SetPosition(id, *vector3);
87140 }
87141
87142 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
87143   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87144   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87145   return proxy->BakePosition(id, *vector3);
87146 }
87147
87148 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
87149   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87150   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87151   return proxy->GetSize(id, *vector3);
87152 }
87153
87154 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
87155   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87156   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87157   return proxy->SetSize(id, *vector3);
87158 }
87159 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
87160   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87161   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87162   return proxy->BakeSize(id, *vector3);
87163 }
87164
87165 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
87166   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87167   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
87168   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
87169   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
87170 }
87171
87172 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
87173   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87174   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87175   return proxy->GetScale(id,* vector3);
87176 }
87177
87178 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
87179   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87180   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87181   return proxy->SetScale(id, *vector3);
87182 }
87183
87184 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
87185   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87186   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87187   return proxy->BakeScale(id, *vector3);
87188 }
87189
87190 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
87191   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87192   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87193   return proxy->GetColor(id, *vector4);
87194 }
87195
87196 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
87197   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87198   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87199   return proxy->SetColor(id, *vector4);
87200 }
87201
87202 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
87203   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87204   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87205   return proxy->BakeColor(id, *vector4);
87206 }
87207
87208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
87209   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87210   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87211
87212   Dali::Stage *arg1 = (Dali::Stage *) 0;
87213   Dali::Actor *arg3 = 0;
87214
87215   arg1 = (Dali::Stage *)jarg1;
87216   arg3 = (Dali::Actor *)jarg3;
87217
87218   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
87219   return;
87220 }
87221
87222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
87223
87224   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87225   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87226
87227   Dali::Stage *arg1 = (Dali::Stage *) 0;
87228
87229   arg1 = (Dali::Stage *)jarg1;
87230
87231   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
87232   return;
87233 }
87234
87235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87236   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87237   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87238   if (director) {
87239     director->swig_connect_director(callback0);
87240   }
87241 }
87242
87243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87244   KeyboardFocusManager arg1 ;
87245   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87246   KeyboardFocusManager *argp1 ;
87247
87248   argp1 = (KeyboardFocusManager *)jarg1;
87249   if (!argp1) {
87250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87251     return ;
87252   }
87253   arg1 = *argp1;
87254   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87255   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87256   {
87257     try {
87258       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87259     } catch (std::out_of_range& e) {
87260       {
87261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87262       };
87263     } catch (std::exception& e) {
87264       {
87265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87266       };
87267     } catch (Dali::DaliException e) {
87268       {
87269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87270       };
87271     } catch (...) {
87272       {
87273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87274       };
87275     }
87276   }
87277
87278 }
87279
87280
87281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87282   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87283
87284   arg1 = (std::vector< unsigned int > *)jarg1;
87285   {
87286     try {
87287       (arg1)->clear();
87288     } catch (std::out_of_range& e) {
87289       {
87290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87291       };
87292     } catch (std::exception& e) {
87293       {
87294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87295       };
87296     } catch (Dali::DaliException e) {
87297       {
87298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87299       };
87300     } catch (...) {
87301       {
87302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87303       };
87304     }
87305   }
87306
87307 }
87308
87309
87310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87311   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87312   unsigned int *arg2 = 0 ;
87313   unsigned int temp2 ;
87314
87315   arg1 = (std::vector< unsigned int > *)jarg1;
87316   temp2 = (unsigned int)jarg2;
87317   arg2 = &temp2;
87318   {
87319     try {
87320       (arg1)->push_back((unsigned int const &)*arg2);
87321     } catch (std::out_of_range& e) {
87322       {
87323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87324       };
87325     } catch (std::exception& e) {
87326       {
87327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87328       };
87329     } catch (Dali::DaliException e) {
87330       {
87331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87332       };
87333     } catch (...) {
87334       {
87335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87336       };
87337     }
87338   }
87339
87340 }
87341
87342
87343 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87344   unsigned long jresult ;
87345   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87346   std::vector< unsigned int >::size_type result;
87347
87348   arg1 = (std::vector< unsigned int > *)jarg1;
87349   {
87350     try {
87351       result = ((std::vector< unsigned int > const *)arg1)->size();
87352     } catch (std::out_of_range& e) {
87353       {
87354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87355       };
87356     } catch (std::exception& e) {
87357       {
87358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87359       };
87360     } catch (Dali::DaliException e) {
87361       {
87362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87363       };
87364     } catch (...) {
87365       {
87366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87367       };
87368     }
87369   }
87370
87371   jresult = (unsigned long)result;
87372   return jresult;
87373 }
87374
87375
87376 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87377   unsigned long jresult ;
87378   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87379   std::vector< unsigned int >::size_type result;
87380
87381   arg1 = (std::vector< unsigned int > *)jarg1;
87382   {
87383     try {
87384       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87385     } catch (std::out_of_range& e) {
87386       {
87387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87388       };
87389     } catch (std::exception& e) {
87390       {
87391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87392       };
87393     } catch (Dali::DaliException e) {
87394       {
87395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87396       };
87397     } catch (...) {
87398       {
87399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87400       };
87401     }
87402   }
87403
87404   jresult = (unsigned long)result;
87405   return jresult;
87406 }
87407
87408
87409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87410   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87411   std::vector< unsigned int >::size_type arg2 ;
87412
87413   arg1 = (std::vector< unsigned int > *)jarg1;
87414   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87415   {
87416     try {
87417       (arg1)->reserve(arg2);
87418     } catch (std::out_of_range& e) {
87419       {
87420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87421       };
87422     } catch (std::exception& e) {
87423       {
87424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87425       };
87426     } catch (Dali::DaliException e) {
87427       {
87428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87429       };
87430     } catch (...) {
87431       {
87432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87433       };
87434     }
87435   }
87436
87437 }
87438
87439
87440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87441   void * jresult ;
87442   std::vector< unsigned int > *result = 0 ;
87443
87444   {
87445     try {
87446       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87447     } catch (std::out_of_range& e) {
87448       {
87449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87450       };
87451     } catch (std::exception& e) {
87452       {
87453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87454       };
87455     } catch (Dali::DaliException e) {
87456       {
87457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87458       };
87459     } catch (...) {
87460       {
87461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87462       };
87463     }
87464   }
87465
87466   jresult = (void *)result;
87467   return jresult;
87468 }
87469
87470
87471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87472   void * jresult ;
87473   std::vector< unsigned int > *arg1 = 0 ;
87474   std::vector< unsigned int > *result = 0 ;
87475
87476   arg1 = (std::vector< unsigned int > *)jarg1;
87477   if (!arg1) {
87478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87479     return 0;
87480   }
87481   {
87482     try {
87483       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87484     } catch (std::out_of_range& e) {
87485       {
87486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87487       };
87488     } catch (std::exception& e) {
87489       {
87490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87491       };
87492     } catch (Dali::DaliException e) {
87493       {
87494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87495       };
87496     } catch (...) {
87497       {
87498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87499       };
87500     }
87501   }
87502
87503   jresult = (void *)result;
87504   return jresult;
87505 }
87506
87507
87508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87509   void * jresult ;
87510   int arg1 ;
87511   std::vector< unsigned int > *result = 0 ;
87512
87513   arg1 = (int)jarg1;
87514   {
87515     try {
87516       try {
87517         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87518       }
87519       catch(std::out_of_range &_e) {
87520         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87521         return 0;
87522       }
87523
87524     } catch (std::out_of_range& e) {
87525       {
87526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87527       };
87528     } catch (std::exception& e) {
87529       {
87530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87531       };
87532     } catch (Dali::DaliException e) {
87533       {
87534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87535       };
87536     } catch (...) {
87537       {
87538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87539       };
87540     }
87541   }
87542
87543   jresult = (void *)result;
87544   return jresult;
87545 }
87546
87547
87548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87549   unsigned int jresult ;
87550   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87551   int arg2 ;
87552   unsigned int result;
87553
87554   arg1 = (std::vector< unsigned int > *)jarg1;
87555   arg2 = (int)jarg2;
87556   {
87557     try {
87558       try {
87559         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87560       }
87561       catch(std::out_of_range &_e) {
87562         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87563         return 0;
87564       }
87565
87566     } catch (std::out_of_range& e) {
87567       {
87568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87569       };
87570     } catch (std::exception& e) {
87571       {
87572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87573       };
87574     } catch (Dali::DaliException e) {
87575       {
87576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87577       };
87578     } catch (...) {
87579       {
87580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87581       };
87582     }
87583   }
87584
87585   jresult = result;
87586   return jresult;
87587 }
87588
87589
87590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87591   unsigned int jresult ;
87592   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87593   int arg2 ;
87594   unsigned int *result = 0 ;
87595
87596   arg1 = (std::vector< unsigned int > *)jarg1;
87597   arg2 = (int)jarg2;
87598   {
87599     try {
87600       try {
87601         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87602       }
87603       catch(std::out_of_range &_e) {
87604         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87605         return 0;
87606       }
87607
87608     } catch (std::out_of_range& e) {
87609       {
87610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87611       };
87612     } catch (std::exception& e) {
87613       {
87614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87615       };
87616     } catch (Dali::DaliException e) {
87617       {
87618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87619       };
87620     } catch (...) {
87621       {
87622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87623       };
87624     }
87625   }
87626
87627   jresult = *result;
87628   return jresult;
87629 }
87630
87631
87632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87633   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87634   int arg2 ;
87635   unsigned int *arg3 = 0 ;
87636   unsigned int temp3 ;
87637
87638   arg1 = (std::vector< unsigned int > *)jarg1;
87639   arg2 = (int)jarg2;
87640   temp3 = (unsigned int)jarg3;
87641   arg3 = &temp3;
87642   {
87643     try {
87644       try {
87645         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87646       }
87647       catch(std::out_of_range &_e) {
87648         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87649         return ;
87650       }
87651
87652     } catch (std::out_of_range& e) {
87653       {
87654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87655       };
87656     } catch (std::exception& e) {
87657       {
87658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87659       };
87660     } catch (Dali::DaliException e) {
87661       {
87662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87663       };
87664     } catch (...) {
87665       {
87666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87667       };
87668     }
87669   }
87670
87671 }
87672
87673
87674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87675   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87676   std::vector< unsigned int > *arg2 = 0 ;
87677
87678   arg1 = (std::vector< unsigned int > *)jarg1;
87679   arg2 = (std::vector< unsigned int > *)jarg2;
87680   if (!arg2) {
87681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87682     return ;
87683   }
87684   {
87685     try {
87686       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87687     } catch (std::out_of_range& e) {
87688       {
87689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87690       };
87691     } catch (std::exception& e) {
87692       {
87693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87694       };
87695     } catch (Dali::DaliException e) {
87696       {
87697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87698       };
87699     } catch (...) {
87700       {
87701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87702       };
87703     }
87704   }
87705
87706 }
87707
87708
87709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87710   void * jresult ;
87711   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87712   int arg2 ;
87713   int arg3 ;
87714   std::vector< unsigned int > *result = 0 ;
87715
87716   arg1 = (std::vector< unsigned int > *)jarg1;
87717   arg2 = (int)jarg2;
87718   arg3 = (int)jarg3;
87719   {
87720     try {
87721       try {
87722         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87723       }
87724       catch(std::out_of_range &_e) {
87725         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87726         return 0;
87727       }
87728       catch(std::invalid_argument &_e) {
87729         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87730         return 0;
87731       }
87732
87733     } catch (std::out_of_range& e) {
87734       {
87735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87736       };
87737     } catch (std::exception& e) {
87738       {
87739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87740       };
87741     } catch (Dali::DaliException e) {
87742       {
87743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87744       };
87745     } catch (...) {
87746       {
87747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87748       };
87749     }
87750   }
87751
87752   jresult = (void *)result;
87753   return jresult;
87754 }
87755
87756
87757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87758   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87759   int arg2 ;
87760   unsigned int *arg3 = 0 ;
87761   unsigned int temp3 ;
87762
87763   arg1 = (std::vector< unsigned int > *)jarg1;
87764   arg2 = (int)jarg2;
87765   temp3 = (unsigned int)jarg3;
87766   arg3 = &temp3;
87767   {
87768     try {
87769       try {
87770         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87771       }
87772       catch(std::out_of_range &_e) {
87773         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87774         return ;
87775       }
87776
87777     } catch (std::out_of_range& e) {
87778       {
87779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87780       };
87781     } catch (std::exception& e) {
87782       {
87783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87784       };
87785     } catch (Dali::DaliException e) {
87786       {
87787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87788       };
87789     } catch (...) {
87790       {
87791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87792       };
87793     }
87794   }
87795
87796 }
87797
87798
87799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87800   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87801   int arg2 ;
87802   std::vector< unsigned int > *arg3 = 0 ;
87803
87804   arg1 = (std::vector< unsigned int > *)jarg1;
87805   arg2 = (int)jarg2;
87806   arg3 = (std::vector< unsigned int > *)jarg3;
87807   if (!arg3) {
87808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87809     return ;
87810   }
87811   {
87812     try {
87813       try {
87814         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87815       }
87816       catch(std::out_of_range &_e) {
87817         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87818         return ;
87819       }
87820
87821     } catch (std::out_of_range& e) {
87822       {
87823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87824       };
87825     } catch (std::exception& e) {
87826       {
87827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87828       };
87829     } catch (Dali::DaliException e) {
87830       {
87831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87832       };
87833     } catch (...) {
87834       {
87835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87836       };
87837     }
87838   }
87839
87840 }
87841
87842
87843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87844   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87845   int arg2 ;
87846
87847   arg1 = (std::vector< unsigned int > *)jarg1;
87848   arg2 = (int)jarg2;
87849   {
87850     try {
87851       try {
87852         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87853       }
87854       catch(std::out_of_range &_e) {
87855         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87856         return ;
87857       }
87858
87859     } catch (std::out_of_range& e) {
87860       {
87861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87862       };
87863     } catch (std::exception& e) {
87864       {
87865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87866       };
87867     } catch (Dali::DaliException e) {
87868       {
87869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87870       };
87871     } catch (...) {
87872       {
87873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87874       };
87875     }
87876   }
87877
87878 }
87879
87880
87881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87882   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87883   int arg2 ;
87884   int arg3 ;
87885
87886   arg1 = (std::vector< unsigned int > *)jarg1;
87887   arg2 = (int)jarg2;
87888   arg3 = (int)jarg3;
87889   {
87890     try {
87891       try {
87892         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87893       }
87894       catch(std::out_of_range &_e) {
87895         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87896         return ;
87897       }
87898       catch(std::invalid_argument &_e) {
87899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87900         return ;
87901       }
87902
87903     } catch (std::out_of_range& e) {
87904       {
87905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87906       };
87907     } catch (std::exception& e) {
87908       {
87909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87910       };
87911     } catch (Dali::DaliException e) {
87912       {
87913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87914       };
87915     } catch (...) {
87916       {
87917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87918       };
87919     }
87920   }
87921
87922 }
87923
87924
87925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87926   void * jresult ;
87927   unsigned int *arg1 = 0 ;
87928   int arg2 ;
87929   unsigned int temp1 ;
87930   std::vector< unsigned int > *result = 0 ;
87931
87932   temp1 = (unsigned int)jarg1;
87933   arg1 = &temp1;
87934   arg2 = (int)jarg2;
87935   {
87936     try {
87937       try {
87938         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87939       }
87940       catch(std::out_of_range &_e) {
87941         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87942         return 0;
87943       }
87944
87945     } catch (std::out_of_range& e) {
87946       {
87947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87948       };
87949     } catch (std::exception& e) {
87950       {
87951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87952       };
87953     } catch (Dali::DaliException e) {
87954       {
87955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87956       };
87957     } catch (...) {
87958       {
87959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87960       };
87961     }
87962   }
87963
87964   jresult = (void *)result;
87965   return jresult;
87966 }
87967
87968
87969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87970   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87971
87972   arg1 = (std::vector< unsigned int > *)jarg1;
87973   {
87974     try {
87975       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87976     } catch (std::out_of_range& e) {
87977       {
87978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87979       };
87980     } catch (std::exception& e) {
87981       {
87982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87983       };
87984     } catch (Dali::DaliException e) {
87985       {
87986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87987       };
87988     } catch (...) {
87989       {
87990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87991       };
87992     }
87993   }
87994
87995 }
87996
87997
87998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87999   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88000   int arg2 ;
88001   int arg3 ;
88002
88003   arg1 = (std::vector< unsigned int > *)jarg1;
88004   arg2 = (int)jarg2;
88005   arg3 = (int)jarg3;
88006   {
88007     try {
88008       try {
88009         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88010       }
88011       catch(std::out_of_range &_e) {
88012         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88013         return ;
88014       }
88015       catch(std::invalid_argument &_e) {
88016         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88017         return ;
88018       }
88019
88020     } catch (std::out_of_range& e) {
88021       {
88022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88023       };
88024     } catch (std::exception& e) {
88025       {
88026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88027       };
88028     } catch (Dali::DaliException e) {
88029       {
88030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88031       };
88032     } catch (...) {
88033       {
88034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88035       };
88036     }
88037   }
88038
88039 }
88040
88041
88042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88043   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88044   int arg2 ;
88045   std::vector< unsigned int > *arg3 = 0 ;
88046
88047   arg1 = (std::vector< unsigned int > *)jarg1;
88048   arg2 = (int)jarg2;
88049   arg3 = (std::vector< unsigned int > *)jarg3;
88050   if (!arg3) {
88051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88052     return ;
88053   }
88054   {
88055     try {
88056       try {
88057         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
88058       }
88059       catch(std::out_of_range &_e) {
88060         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88061         return ;
88062       }
88063
88064     } catch (std::out_of_range& e) {
88065       {
88066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88067       };
88068     } catch (std::exception& e) {
88069       {
88070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88071       };
88072     } catch (Dali::DaliException e) {
88073       {
88074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88075       };
88076     } catch (...) {
88077       {
88078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88079       };
88080     }
88081   }
88082
88083 }
88084
88085
88086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
88087   unsigned int jresult ;
88088   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88089   unsigned int *arg2 = 0 ;
88090   unsigned int temp2 ;
88091   bool result;
88092
88093   arg1 = (std::vector< unsigned int > *)jarg1;
88094   temp2 = (unsigned int)jarg2;
88095   arg2 = &temp2;
88096   {
88097     try {
88098       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
88099     } catch (std::out_of_range& e) {
88100       {
88101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88102       };
88103     } catch (std::exception& e) {
88104       {
88105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88106       };
88107     } catch (Dali::DaliException e) {
88108       {
88109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88110       };
88111     } catch (...) {
88112       {
88113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88114       };
88115     }
88116   }
88117
88118   jresult = result;
88119   return jresult;
88120 }
88121
88122
88123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
88124   int jresult ;
88125   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88126   unsigned int *arg2 = 0 ;
88127   unsigned int temp2 ;
88128   int result;
88129
88130   arg1 = (std::vector< unsigned int > *)jarg1;
88131   temp2 = (unsigned int)jarg2;
88132   arg2 = &temp2;
88133   {
88134     try {
88135       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
88136     } catch (std::out_of_range& e) {
88137       {
88138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88139       };
88140     } catch (std::exception& e) {
88141       {
88142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88143       };
88144     } catch (Dali::DaliException e) {
88145       {
88146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88147       };
88148     } catch (...) {
88149       {
88150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88151       };
88152     }
88153   }
88154
88155   jresult = result;
88156   return jresult;
88157 }
88158
88159
88160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
88161   int jresult ;
88162   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88163   unsigned int *arg2 = 0 ;
88164   unsigned int temp2 ;
88165   int result;
88166
88167   arg1 = (std::vector< unsigned int > *)jarg1;
88168   temp2 = (unsigned int)jarg2;
88169   arg2 = &temp2;
88170   {
88171     try {
88172       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
88173     } catch (std::out_of_range& e) {
88174       {
88175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88176       };
88177     } catch (std::exception& e) {
88178       {
88179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88180       };
88181     } catch (Dali::DaliException e) {
88182       {
88183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88184       };
88185     } catch (...) {
88186       {
88187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88188       };
88189     }
88190   }
88191
88192   jresult = result;
88193   return jresult;
88194 }
88195
88196
88197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88198   unsigned int jresult ;
88199   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88200   unsigned int *arg2 = 0 ;
88201   unsigned int temp2 ;
88202   bool result;
88203
88204   arg1 = (std::vector< unsigned int > *)jarg1;
88205   temp2 = (unsigned int)jarg2;
88206   arg2 = &temp2;
88207   {
88208     try {
88209       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88210     } catch (std::out_of_range& e) {
88211       {
88212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88213       };
88214     } catch (std::exception& e) {
88215       {
88216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88217       };
88218     } catch (Dali::DaliException e) {
88219       {
88220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88221       };
88222     } catch (...) {
88223       {
88224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88225       };
88226     }
88227   }
88228
88229   jresult = result;
88230   return jresult;
88231 }
88232
88233
88234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88235   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88236
88237   arg1 = (std::vector< unsigned int > *)jarg1;
88238   {
88239     try {
88240       delete arg1;
88241     } catch (std::out_of_range& e) {
88242       {
88243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88244       };
88245     } catch (std::exception& e) {
88246       {
88247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88248       };
88249     } catch (Dali::DaliException e) {
88250       {
88251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88252       };
88253     } catch (...) {
88254       {
88255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88256       };
88257     }
88258   }
88259
88260 }
88261
88262
88263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88264   void * jresult ;
88265   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88266
88267   {
88268     try {
88269       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88270     } catch (std::out_of_range& e) {
88271       {
88272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88273       };
88274     } catch (std::exception& e) {
88275       {
88276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88277       };
88278     } catch (Dali::DaliException e) {
88279       {
88280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88281       };
88282     } catch (...) {
88283       {
88284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88285       };
88286     }
88287   }
88288
88289   jresult = (void *)result;
88290   return jresult;
88291 }
88292
88293
88294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88295   void * jresult ;
88296   unsigned int arg1 ;
88297   Dali::Actor arg2 ;
88298   Dali::Actor *argp2 ;
88299   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88300
88301   arg1 = (unsigned int)jarg1;
88302   argp2 = (Dali::Actor *)jarg2;
88303   if (!argp2) {
88304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88305     return 0;
88306   }
88307   arg2 = *argp2;
88308   {
88309     try {
88310       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88311     } catch (std::out_of_range& e) {
88312       {
88313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88314       };
88315     } catch (std::exception& e) {
88316       {
88317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88318       };
88319     } catch (Dali::DaliException e) {
88320       {
88321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88322       };
88323     } catch (...) {
88324       {
88325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88326       };
88327     }
88328   }
88329
88330   jresult = (void *)result;
88331   return jresult;
88332 }
88333
88334
88335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88336   void * jresult ;
88337   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88338   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88339
88340   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88341   if (!arg1) {
88342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88343     return 0;
88344   }
88345   {
88346     try {
88347       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88348     } catch (std::out_of_range& e) {
88349       {
88350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88351       };
88352     } catch (std::exception& e) {
88353       {
88354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88355       };
88356     } catch (Dali::DaliException e) {
88357       {
88358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88359       };
88360     } catch (...) {
88361       {
88362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88363       };
88364     }
88365   }
88366
88367   jresult = (void *)result;
88368   return jresult;
88369 }
88370
88371
88372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88373   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88374   unsigned int arg2 ;
88375
88376   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88377   arg2 = (unsigned int)jarg2;
88378   if (arg1) (arg1)->first = arg2;
88379 }
88380
88381
88382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88383   unsigned int jresult ;
88384   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88385   unsigned int result;
88386
88387   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88388   result = (unsigned int) ((arg1)->first);
88389   jresult = result;
88390   return jresult;
88391 }
88392
88393
88394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88395   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88396   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88397
88398   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88399   arg2 = (Dali::Actor *)jarg2;
88400   if (arg1) (arg1)->second = *arg2;
88401 }
88402
88403
88404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88405   void * jresult ;
88406   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88407   Dali::Actor *result = 0 ;
88408
88409   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88410   result = (Dali::Actor *)& ((arg1)->second);
88411   jresult = (void *)result;
88412   return jresult;
88413 }
88414
88415
88416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88417   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88418
88419   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88420   {
88421     try {
88422       delete arg1;
88423     } catch (std::out_of_range& e) {
88424       {
88425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88426       };
88427     } catch (std::exception& e) {
88428       {
88429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88430       };
88431     } catch (Dali::DaliException e) {
88432       {
88433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88434       };
88435     } catch (...) {
88436       {
88437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88438       };
88439     }
88440   }
88441
88442 }
88443
88444
88445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88446   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88447
88448   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88449   {
88450     try {
88451       (arg1)->clear();
88452     } catch (std::out_of_range& e) {
88453       {
88454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88455       };
88456     } catch (std::exception& e) {
88457       {
88458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88459       };
88460     } catch (Dali::DaliException e) {
88461       {
88462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88463       };
88464     } catch (...) {
88465       {
88466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88467       };
88468     }
88469   }
88470
88471 }
88472
88473
88474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88475   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88476   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88477
88478   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88479   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88480   if (!arg2) {
88481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88482     return ;
88483   }
88484   {
88485     try {
88486       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88487     } catch (std::out_of_range& e) {
88488       {
88489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88490       };
88491     } catch (std::exception& e) {
88492       {
88493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88494       };
88495     } catch (Dali::DaliException e) {
88496       {
88497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88498       };
88499     } catch (...) {
88500       {
88501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88502       };
88503     }
88504   }
88505
88506 }
88507
88508
88509 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88510   unsigned long jresult ;
88511   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88512   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88513
88514   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88515   {
88516     try {
88517       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88518     } catch (std::out_of_range& e) {
88519       {
88520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88521       };
88522     } catch (std::exception& e) {
88523       {
88524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88525       };
88526     } catch (Dali::DaliException e) {
88527       {
88528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88529       };
88530     } catch (...) {
88531       {
88532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88533       };
88534     }
88535   }
88536
88537   jresult = (unsigned long)result;
88538   return jresult;
88539 }
88540
88541
88542 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88543   unsigned long jresult ;
88544   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88545   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88546
88547   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88548   {
88549     try {
88550       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88551     } catch (std::out_of_range& e) {
88552       {
88553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88554       };
88555     } catch (std::exception& e) {
88556       {
88557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88558       };
88559     } catch (Dali::DaliException e) {
88560       {
88561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88562       };
88563     } catch (...) {
88564       {
88565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88566       };
88567     }
88568   }
88569
88570   jresult = (unsigned long)result;
88571   return jresult;
88572 }
88573
88574
88575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88576   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88577   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88578
88579   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88580   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88581   {
88582     try {
88583       (arg1)->reserve(arg2);
88584     } catch (std::out_of_range& e) {
88585       {
88586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88587       };
88588     } catch (std::exception& e) {
88589       {
88590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88591       };
88592     } catch (Dali::DaliException e) {
88593       {
88594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88595       };
88596     } catch (...) {
88597       {
88598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88599       };
88600     }
88601   }
88602
88603 }
88604
88605
88606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88607   void * jresult ;
88608   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88609
88610   {
88611     try {
88612       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88613     } catch (std::out_of_range& e) {
88614       {
88615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88616       };
88617     } catch (std::exception& e) {
88618       {
88619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88620       };
88621     } catch (Dali::DaliException e) {
88622       {
88623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88624       };
88625     } catch (...) {
88626       {
88627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88628       };
88629     }
88630   }
88631
88632   jresult = (void *)result;
88633   return jresult;
88634 }
88635
88636
88637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88638   void * jresult ;
88639   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88640   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88641
88642   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88643   if (!arg1) {
88644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88645     return 0;
88646   }
88647   {
88648     try {
88649       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);
88650     } catch (std::out_of_range& e) {
88651       {
88652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88653       };
88654     } catch (std::exception& e) {
88655       {
88656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88657       };
88658     } catch (Dali::DaliException e) {
88659       {
88660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88661       };
88662     } catch (...) {
88663       {
88664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88665       };
88666     }
88667   }
88668
88669   jresult = (void *)result;
88670   return jresult;
88671 }
88672
88673
88674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88675   void * jresult ;
88676   int arg1 ;
88677   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88678
88679   arg1 = (int)jarg1;
88680   {
88681     try {
88682       try {
88683         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);
88684       }
88685       catch(std::out_of_range &_e) {
88686         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88687         return 0;
88688       }
88689
88690     } catch (std::out_of_range& e) {
88691       {
88692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88693       };
88694     } catch (std::exception& e) {
88695       {
88696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88697       };
88698     } catch (Dali::DaliException e) {
88699       {
88700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88701       };
88702     } catch (...) {
88703       {
88704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88705       };
88706     }
88707   }
88708
88709   jresult = (void *)result;
88710   return jresult;
88711 }
88712
88713
88714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88715   void * jresult ;
88716   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88717   int arg2 ;
88718   std::pair< unsigned int,Dali::Actor > result;
88719
88720   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88721   arg2 = (int)jarg2;
88722   {
88723     try {
88724       try {
88725         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88726       }
88727       catch(std::out_of_range &_e) {
88728         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88729         return 0;
88730       }
88731
88732     } catch (std::out_of_range& e) {
88733       {
88734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88735       };
88736     } catch (std::exception& e) {
88737       {
88738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88739       };
88740     } catch (Dali::DaliException e) {
88741       {
88742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88743       };
88744     } catch (...) {
88745       {
88746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88747       };
88748     }
88749   }
88750
88751   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88752   return jresult;
88753 }
88754
88755
88756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88757   void * jresult ;
88758   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88759   int arg2 ;
88760   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88761
88762   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88763   arg2 = (int)jarg2;
88764   {
88765     try {
88766       try {
88767         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88768       }
88769       catch(std::out_of_range &_e) {
88770         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88771         return 0;
88772       }
88773
88774     } catch (std::out_of_range& e) {
88775       {
88776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88777       };
88778     } catch (std::exception& e) {
88779       {
88780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88781       };
88782     } catch (Dali::DaliException e) {
88783       {
88784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88785       };
88786     } catch (...) {
88787       {
88788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88789       };
88790     }
88791   }
88792
88793   jresult = (void *)result;
88794   return jresult;
88795 }
88796
88797
88798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88799   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88800   int arg2 ;
88801   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88802
88803   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88804   arg2 = (int)jarg2;
88805   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88806   if (!arg3) {
88807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88808     return ;
88809   }
88810   {
88811     try {
88812       try {
88813         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);
88814       }
88815       catch(std::out_of_range &_e) {
88816         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88817         return ;
88818       }
88819
88820     } catch (std::out_of_range& e) {
88821       {
88822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88823       };
88824     } catch (std::exception& e) {
88825       {
88826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88827       };
88828     } catch (Dali::DaliException e) {
88829       {
88830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88831       };
88832     } catch (...) {
88833       {
88834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88835       };
88836     }
88837   }
88838
88839 }
88840
88841
88842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88843   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88844   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88845
88846   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88847   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88848   if (!arg2) {
88849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88850     return ;
88851   }
88852   {
88853     try {
88854       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);
88855     } catch (std::out_of_range& e) {
88856       {
88857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88858       };
88859     } catch (std::exception& e) {
88860       {
88861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88862       };
88863     } catch (Dali::DaliException e) {
88864       {
88865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88866       };
88867     } catch (...) {
88868       {
88869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88870       };
88871     }
88872   }
88873
88874 }
88875
88876
88877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88878   void * jresult ;
88879   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88880   int arg2 ;
88881   int arg3 ;
88882   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88883
88884   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88885   arg2 = (int)jarg2;
88886   arg3 = (int)jarg3;
88887   {
88888     try {
88889       try {
88890         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);
88891       }
88892       catch(std::out_of_range &_e) {
88893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88894         return 0;
88895       }
88896       catch(std::invalid_argument &_e) {
88897         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88898         return 0;
88899       }
88900
88901     } catch (std::out_of_range& e) {
88902       {
88903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88904       };
88905     } catch (std::exception& e) {
88906       {
88907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88908       };
88909     } catch (Dali::DaliException e) {
88910       {
88911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88912       };
88913     } catch (...) {
88914       {
88915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88916       };
88917     }
88918   }
88919
88920   jresult = (void *)result;
88921   return jresult;
88922 }
88923
88924
88925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88926   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88927   int arg2 ;
88928   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88929
88930   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88931   arg2 = (int)jarg2;
88932   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88933   if (!arg3) {
88934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88935     return ;
88936   }
88937   {
88938     try {
88939       try {
88940         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);
88941       }
88942       catch(std::out_of_range &_e) {
88943         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88944         return ;
88945       }
88946
88947     } catch (std::out_of_range& e) {
88948       {
88949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88950       };
88951     } catch (std::exception& e) {
88952       {
88953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88954       };
88955     } catch (Dali::DaliException e) {
88956       {
88957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88958       };
88959     } catch (...) {
88960       {
88961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88962       };
88963     }
88964   }
88965
88966 }
88967
88968
88969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88970   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88971   int arg2 ;
88972   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88973
88974   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88975   arg2 = (int)jarg2;
88976   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88977   if (!arg3) {
88978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88979     return ;
88980   }
88981   {
88982     try {
88983       try {
88984         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);
88985       }
88986       catch(std::out_of_range &_e) {
88987         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88988         return ;
88989       }
88990
88991     } catch (std::out_of_range& e) {
88992       {
88993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88994       };
88995     } catch (std::exception& e) {
88996       {
88997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88998       };
88999     } catch (Dali::DaliException e) {
89000       {
89001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89002       };
89003     } catch (...) {
89004       {
89005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89006       };
89007     }
89008   }
89009
89010 }
89011
89012
89013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
89014   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89015   int arg2 ;
89016
89017   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89018   arg2 = (int)jarg2;
89019   {
89020     try {
89021       try {
89022         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
89023       }
89024       catch(std::out_of_range &_e) {
89025         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89026         return ;
89027       }
89028
89029     } catch (std::out_of_range& e) {
89030       {
89031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89032       };
89033     } catch (std::exception& e) {
89034       {
89035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89036       };
89037     } catch (Dali::DaliException e) {
89038       {
89039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89040       };
89041     } catch (...) {
89042       {
89043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89044       };
89045     }
89046   }
89047
89048 }
89049
89050
89051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89052   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89053   int arg2 ;
89054   int arg3 ;
89055
89056   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89057   arg2 = (int)jarg2;
89058   arg3 = (int)jarg3;
89059   {
89060     try {
89061       try {
89062         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
89063       }
89064       catch(std::out_of_range &_e) {
89065         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89066         return ;
89067       }
89068       catch(std::invalid_argument &_e) {
89069         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89070         return ;
89071       }
89072
89073     } catch (std::out_of_range& e) {
89074       {
89075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89076       };
89077     } catch (std::exception& e) {
89078       {
89079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89080       };
89081     } catch (Dali::DaliException e) {
89082       {
89083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89084       };
89085     } catch (...) {
89086       {
89087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89088       };
89089     }
89090   }
89091
89092 }
89093
89094
89095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
89096   void * jresult ;
89097   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
89098   int arg2 ;
89099   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89100
89101   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89102   if (!arg1) {
89103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89104     return 0;
89105   }
89106   arg2 = (int)jarg2;
89107   {
89108     try {
89109       try {
89110         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);
89111       }
89112       catch(std::out_of_range &_e) {
89113         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89114         return 0;
89115       }
89116
89117     } catch (std::out_of_range& e) {
89118       {
89119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89120       };
89121     } catch (std::exception& e) {
89122       {
89123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89124       };
89125     } catch (Dali::DaliException e) {
89126       {
89127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89128       };
89129     } catch (...) {
89130       {
89131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89132       };
89133     }
89134   }
89135
89136   jresult = (void *)result;
89137   return jresult;
89138 }
89139
89140
89141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
89142   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89143
89144   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89145   {
89146     try {
89147       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
89148     } catch (std::out_of_range& e) {
89149       {
89150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89151       };
89152     } catch (std::exception& e) {
89153       {
89154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89155       };
89156     } catch (Dali::DaliException e) {
89157       {
89158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89159       };
89160     } catch (...) {
89161       {
89162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89163       };
89164     }
89165   }
89166
89167 }
89168
89169
89170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89171   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89172   int arg2 ;
89173   int arg3 ;
89174
89175   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89176   arg2 = (int)jarg2;
89177   arg3 = (int)jarg3;
89178   {
89179     try {
89180       try {
89181         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89182       }
89183       catch(std::out_of_range &_e) {
89184         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89185         return ;
89186       }
89187       catch(std::invalid_argument &_e) {
89188         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89189         return ;
89190       }
89191
89192     } catch (std::out_of_range& e) {
89193       {
89194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89195       };
89196     } catch (std::exception& e) {
89197       {
89198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89199       };
89200     } catch (Dali::DaliException e) {
89201       {
89202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89203       };
89204     } catch (...) {
89205       {
89206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89207       };
89208     }
89209   }
89210
89211 }
89212
89213
89214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89215   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89216   int arg2 ;
89217   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89218
89219   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89220   arg2 = (int)jarg2;
89221   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89222   if (!arg3) {
89223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89224     return ;
89225   }
89226   {
89227     try {
89228       try {
89229         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);
89230       }
89231       catch(std::out_of_range &_e) {
89232         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89233         return ;
89234       }
89235
89236     } catch (std::out_of_range& e) {
89237       {
89238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89239       };
89240     } catch (std::exception& e) {
89241       {
89242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89243       };
89244     } catch (Dali::DaliException e) {
89245       {
89246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89247       };
89248     } catch (...) {
89249       {
89250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89251       };
89252     }
89253   }
89254
89255 }
89256
89257
89258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89259   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89260
89261   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89262   {
89263     try {
89264       delete arg1;
89265     } catch (std::out_of_range& e) {
89266       {
89267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89268       };
89269     } catch (std::exception& e) {
89270       {
89271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89272       };
89273     } catch (Dali::DaliException e) {
89274       {
89275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89276       };
89277     } catch (...) {
89278       {
89279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89280       };
89281     }
89282   }
89283
89284 }
89285
89286
89287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89288   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89289
89290   arg1 = (std::vector< Dali::Actor > *)jarg1;
89291   {
89292     try {
89293       (arg1)->clear();
89294     } catch (std::out_of_range& e) {
89295       {
89296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89297       };
89298     } catch (std::exception& e) {
89299       {
89300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89301       };
89302     } catch (Dali::DaliException e) {
89303       {
89304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89305       };
89306     } catch (...) {
89307       {
89308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89309       };
89310     }
89311   }
89312
89313 }
89314
89315
89316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89317   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89318   Dali::Actor *arg2 = 0 ;
89319
89320   arg1 = (std::vector< Dali::Actor > *)jarg1;
89321   arg2 = (Dali::Actor *)jarg2;
89322   if (!arg2) {
89323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89324     return ;
89325   }
89326   {
89327     try {
89328       (arg1)->push_back((Dali::Actor const &)*arg2);
89329     } catch (std::out_of_range& e) {
89330       {
89331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89332       };
89333     } catch (std::exception& e) {
89334       {
89335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89336       };
89337     } catch (Dali::DaliException e) {
89338       {
89339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89340       };
89341     } catch (...) {
89342       {
89343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89344       };
89345     }
89346   }
89347
89348 }
89349
89350
89351 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89352   unsigned long jresult ;
89353   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89354   std::vector< Dali::Actor >::size_type result;
89355
89356   arg1 = (std::vector< Dali::Actor > *)jarg1;
89357   {
89358     try {
89359       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89360     } catch (std::out_of_range& e) {
89361       {
89362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89363       };
89364     } catch (std::exception& e) {
89365       {
89366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89367       };
89368     } catch (Dali::DaliException e) {
89369       {
89370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89371       };
89372     } catch (...) {
89373       {
89374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89375       };
89376     }
89377   }
89378
89379   jresult = (unsigned long)result;
89380   return jresult;
89381 }
89382
89383
89384 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89385   unsigned long jresult ;
89386   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89387   std::vector< Dali::Actor >::size_type result;
89388
89389   arg1 = (std::vector< Dali::Actor > *)jarg1;
89390   {
89391     try {
89392       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89393     } catch (std::out_of_range& e) {
89394       {
89395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89396       };
89397     } catch (std::exception& e) {
89398       {
89399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89400       };
89401     } catch (Dali::DaliException e) {
89402       {
89403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89404       };
89405     } catch (...) {
89406       {
89407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89408       };
89409     }
89410   }
89411
89412   jresult = (unsigned long)result;
89413   return jresult;
89414 }
89415
89416
89417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89418   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89419   std::vector< Dali::Actor >::size_type arg2 ;
89420
89421   arg1 = (std::vector< Dali::Actor > *)jarg1;
89422   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89423   {
89424     try {
89425       (arg1)->reserve(arg2);
89426     } catch (std::out_of_range& e) {
89427       {
89428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89429       };
89430     } catch (std::exception& e) {
89431       {
89432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89433       };
89434     } catch (Dali::DaliException e) {
89435       {
89436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89437       };
89438     } catch (...) {
89439       {
89440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89441       };
89442     }
89443   }
89444
89445 }
89446
89447
89448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89449   void * jresult ;
89450   std::vector< Dali::Actor > *result = 0 ;
89451
89452   {
89453     try {
89454       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89455     } catch (std::out_of_range& e) {
89456       {
89457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89458       };
89459     } catch (std::exception& e) {
89460       {
89461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89462       };
89463     } catch (Dali::DaliException e) {
89464       {
89465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89466       };
89467     } catch (...) {
89468       {
89469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89470       };
89471     }
89472   }
89473
89474   jresult = (void *)result;
89475   return jresult;
89476 }
89477
89478
89479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89480   void * jresult ;
89481   std::vector< Dali::Actor > *arg1 = 0 ;
89482   std::vector< Dali::Actor > *result = 0 ;
89483
89484   arg1 = (std::vector< Dali::Actor > *)jarg1;
89485   if (!arg1) {
89486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89487     return 0;
89488   }
89489   {
89490     try {
89491       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89492     } catch (std::out_of_range& e) {
89493       {
89494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89495       };
89496     } catch (std::exception& e) {
89497       {
89498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89499       };
89500     } catch (Dali::DaliException e) {
89501       {
89502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89503       };
89504     } catch (...) {
89505       {
89506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89507       };
89508     }
89509   }
89510
89511   jresult = (void *)result;
89512   return jresult;
89513 }
89514
89515
89516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89517   void * jresult ;
89518   int arg1 ;
89519   std::vector< Dali::Actor > *result = 0 ;
89520
89521   arg1 = (int)jarg1;
89522   {
89523     try {
89524       try {
89525         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89526       }
89527       catch(std::out_of_range &_e) {
89528         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89529         return 0;
89530       }
89531
89532     } catch (std::out_of_range& e) {
89533       {
89534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89535       };
89536     } catch (std::exception& e) {
89537       {
89538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89539       };
89540     } catch (Dali::DaliException e) {
89541       {
89542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89543       };
89544     } catch (...) {
89545       {
89546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89547       };
89548     }
89549   }
89550
89551   jresult = (void *)result;
89552   return jresult;
89553 }
89554
89555
89556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89557   void * jresult ;
89558   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89559   int arg2 ;
89560   Dali::Actor result;
89561
89562   arg1 = (std::vector< Dali::Actor > *)jarg1;
89563   arg2 = (int)jarg2;
89564   {
89565     try {
89566       try {
89567         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89568       }
89569       catch(std::out_of_range &_e) {
89570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89571         return 0;
89572       }
89573
89574     } catch (std::out_of_range& e) {
89575       {
89576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89577       };
89578     } catch (std::exception& e) {
89579       {
89580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89581       };
89582     } catch (Dali::DaliException e) {
89583       {
89584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89585       };
89586     } catch (...) {
89587       {
89588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89589       };
89590     }
89591   }
89592
89593   jresult = new Dali::Actor((const Dali::Actor &)result);
89594   return jresult;
89595 }
89596
89597
89598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89599   void * jresult ;
89600   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89601   int arg2 ;
89602   Dali::Actor *result = 0 ;
89603
89604   arg1 = (std::vector< Dali::Actor > *)jarg1;
89605   arg2 = (int)jarg2;
89606   {
89607     try {
89608       try {
89609         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89610       }
89611       catch(std::out_of_range &_e) {
89612         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89613         return 0;
89614       }
89615
89616     } catch (std::out_of_range& e) {
89617       {
89618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89619       };
89620     } catch (std::exception& e) {
89621       {
89622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89623       };
89624     } catch (Dali::DaliException e) {
89625       {
89626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89627       };
89628     } catch (...) {
89629       {
89630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89631       };
89632     }
89633   }
89634
89635   jresult = (void *)result;
89636   return jresult;
89637 }
89638
89639
89640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89641   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89642   int arg2 ;
89643   Dali::Actor *arg3 = 0 ;
89644
89645   arg1 = (std::vector< Dali::Actor > *)jarg1;
89646   arg2 = (int)jarg2;
89647   arg3 = (Dali::Actor *)jarg3;
89648   if (!arg3) {
89649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89650     return ;
89651   }
89652   {
89653     try {
89654       try {
89655         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89656       }
89657       catch(std::out_of_range &_e) {
89658         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89659         return ;
89660       }
89661
89662     } catch (std::out_of_range& e) {
89663       {
89664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89665       };
89666     } catch (std::exception& e) {
89667       {
89668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89669       };
89670     } catch (Dali::DaliException e) {
89671       {
89672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89673       };
89674     } catch (...) {
89675       {
89676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89677       };
89678     }
89679   }
89680
89681 }
89682
89683
89684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89685   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89686   std::vector< Dali::Actor > *arg2 = 0 ;
89687
89688   arg1 = (std::vector< Dali::Actor > *)jarg1;
89689   arg2 = (std::vector< Dali::Actor > *)jarg2;
89690   if (!arg2) {
89691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89692     return ;
89693   }
89694   {
89695     try {
89696       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89697     } catch (std::out_of_range& e) {
89698       {
89699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89700       };
89701     } catch (std::exception& e) {
89702       {
89703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89704       };
89705     } catch (Dali::DaliException e) {
89706       {
89707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89708       };
89709     } catch (...) {
89710       {
89711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89712       };
89713     }
89714   }
89715
89716 }
89717
89718
89719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89720   void * jresult ;
89721   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89722   int arg2 ;
89723   int arg3 ;
89724   std::vector< Dali::Actor > *result = 0 ;
89725
89726   arg1 = (std::vector< Dali::Actor > *)jarg1;
89727   arg2 = (int)jarg2;
89728   arg3 = (int)jarg3;
89729   {
89730     try {
89731       try {
89732         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89733       }
89734       catch(std::out_of_range &_e) {
89735         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89736         return 0;
89737       }
89738       catch(std::invalid_argument &_e) {
89739         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89740         return 0;
89741       }
89742
89743     } catch (std::out_of_range& e) {
89744       {
89745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89746       };
89747     } catch (std::exception& e) {
89748       {
89749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89750       };
89751     } catch (Dali::DaliException e) {
89752       {
89753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89754       };
89755     } catch (...) {
89756       {
89757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89758       };
89759     }
89760   }
89761
89762   jresult = (void *)result;
89763   return jresult;
89764 }
89765
89766
89767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89768   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89769   int arg2 ;
89770   Dali::Actor *arg3 = 0 ;
89771
89772   arg1 = (std::vector< Dali::Actor > *)jarg1;
89773   arg2 = (int)jarg2;
89774   arg3 = (Dali::Actor *)jarg3;
89775   if (!arg3) {
89776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89777     return ;
89778   }
89779   {
89780     try {
89781       try {
89782         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89783       }
89784       catch(std::out_of_range &_e) {
89785         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89786         return ;
89787       }
89788
89789     } catch (std::out_of_range& e) {
89790       {
89791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89792       };
89793     } catch (std::exception& e) {
89794       {
89795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89796       };
89797     } catch (Dali::DaliException e) {
89798       {
89799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89800       };
89801     } catch (...) {
89802       {
89803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89804       };
89805     }
89806   }
89807
89808 }
89809
89810
89811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89812   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89813   int arg2 ;
89814   std::vector< Dali::Actor > *arg3 = 0 ;
89815
89816   arg1 = (std::vector< Dali::Actor > *)jarg1;
89817   arg2 = (int)jarg2;
89818   arg3 = (std::vector< Dali::Actor > *)jarg3;
89819   if (!arg3) {
89820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89821     return ;
89822   }
89823   {
89824     try {
89825       try {
89826         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89827       }
89828       catch(std::out_of_range &_e) {
89829         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89830         return ;
89831       }
89832
89833     } catch (std::out_of_range& e) {
89834       {
89835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89836       };
89837     } catch (std::exception& e) {
89838       {
89839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89840       };
89841     } catch (Dali::DaliException e) {
89842       {
89843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89844       };
89845     } catch (...) {
89846       {
89847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89848       };
89849     }
89850   }
89851
89852 }
89853
89854
89855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89856   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89857   int arg2 ;
89858
89859   arg1 = (std::vector< Dali::Actor > *)jarg1;
89860   arg2 = (int)jarg2;
89861   {
89862     try {
89863       try {
89864         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89865       }
89866       catch(std::out_of_range &_e) {
89867         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89868         return ;
89869       }
89870
89871     } catch (std::out_of_range& e) {
89872       {
89873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89874       };
89875     } catch (std::exception& e) {
89876       {
89877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89878       };
89879     } catch (Dali::DaliException e) {
89880       {
89881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89882       };
89883     } catch (...) {
89884       {
89885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89886       };
89887     }
89888   }
89889
89890 }
89891
89892
89893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89894   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89895   int arg2 ;
89896   int arg3 ;
89897
89898   arg1 = (std::vector< Dali::Actor > *)jarg1;
89899   arg2 = (int)jarg2;
89900   arg3 = (int)jarg3;
89901   {
89902     try {
89903       try {
89904         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89905       }
89906       catch(std::out_of_range &_e) {
89907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89908         return ;
89909       }
89910       catch(std::invalid_argument &_e) {
89911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89912         return ;
89913       }
89914
89915     } catch (std::out_of_range& e) {
89916       {
89917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89918       };
89919     } catch (std::exception& e) {
89920       {
89921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89922       };
89923     } catch (Dali::DaliException e) {
89924       {
89925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89926       };
89927     } catch (...) {
89928       {
89929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89930       };
89931     }
89932   }
89933
89934 }
89935
89936
89937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89938   void * jresult ;
89939   Dali::Actor *arg1 = 0 ;
89940   int arg2 ;
89941   std::vector< Dali::Actor > *result = 0 ;
89942
89943   arg1 = (Dali::Actor *)jarg1;
89944   if (!arg1) {
89945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89946     return 0;
89947   }
89948   arg2 = (int)jarg2;
89949   {
89950     try {
89951       try {
89952         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89953       }
89954       catch(std::out_of_range &_e) {
89955         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89956         return 0;
89957       }
89958
89959     } catch (std::out_of_range& e) {
89960       {
89961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89962       };
89963     } catch (std::exception& e) {
89964       {
89965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89966       };
89967     } catch (Dali::DaliException e) {
89968       {
89969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89970       };
89971     } catch (...) {
89972       {
89973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89974       };
89975     }
89976   }
89977
89978   jresult = (void *)result;
89979   return jresult;
89980 }
89981
89982
89983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89984   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89985
89986   arg1 = (std::vector< Dali::Actor > *)jarg1;
89987   {
89988     try {
89989       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89990     } catch (std::out_of_range& e) {
89991       {
89992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89993       };
89994     } catch (std::exception& e) {
89995       {
89996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89997       };
89998     } catch (Dali::DaliException e) {
89999       {
90000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90001       };
90002     } catch (...) {
90003       {
90004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90005       };
90006     }
90007   }
90008
90009 }
90010
90011
90012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
90013   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90014   int arg2 ;
90015   int arg3 ;
90016
90017   arg1 = (std::vector< Dali::Actor > *)jarg1;
90018   arg2 = (int)jarg2;
90019   arg3 = (int)jarg3;
90020   {
90021     try {
90022       try {
90023         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
90024       }
90025       catch(std::out_of_range &_e) {
90026         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90027         return ;
90028       }
90029       catch(std::invalid_argument &_e) {
90030         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90031         return ;
90032       }
90033
90034     } catch (std::out_of_range& e) {
90035       {
90036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90037       };
90038     } catch (std::exception& e) {
90039       {
90040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90041       };
90042     } catch (Dali::DaliException e) {
90043       {
90044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90045       };
90046     } catch (...) {
90047       {
90048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90049       };
90050     }
90051   }
90052
90053 }
90054
90055
90056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
90057   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90058   int arg2 ;
90059   std::vector< Dali::Actor > *arg3 = 0 ;
90060
90061   arg1 = (std::vector< Dali::Actor > *)jarg1;
90062   arg2 = (int)jarg2;
90063   arg3 = (std::vector< Dali::Actor > *)jarg3;
90064   if (!arg3) {
90065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90066     return ;
90067   }
90068   {
90069     try {
90070       try {
90071         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90072       }
90073       catch(std::out_of_range &_e) {
90074         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90075         return ;
90076       }
90077
90078     } catch (std::out_of_range& e) {
90079       {
90080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90081       };
90082     } catch (std::exception& e) {
90083       {
90084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90085       };
90086     } catch (Dali::DaliException e) {
90087       {
90088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90089       };
90090     } catch (...) {
90091       {
90092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90093       };
90094     }
90095   }
90096
90097 }
90098
90099
90100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
90101   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90102
90103   arg1 = (std::vector< Dali::Actor > *)jarg1;
90104   {
90105     try {
90106       delete arg1;
90107     } catch (std::out_of_range& e) {
90108       {
90109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90110       };
90111     } catch (std::exception& e) {
90112       {
90113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90114       };
90115     } catch (Dali::DaliException e) {
90116       {
90117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90118       };
90119     } catch (...) {
90120       {
90121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90122       };
90123     }
90124   }
90125
90126 }
90127
90128
90129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
90130   unsigned int jresult ;
90131   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90132   bool result;
90133
90134   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90135   {
90136     try {
90137       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90138     } catch (std::out_of_range& e) {
90139       {
90140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90141       };
90142     } catch (std::exception& e) {
90143       {
90144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90145       };
90146     } catch (Dali::DaliException e) {
90147       {
90148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90149       };
90150     } catch (...) {
90151       {
90152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90153       };
90154     }
90155   }
90156
90157   jresult = result;
90158   return jresult;
90159 }
90160
90161
90162 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
90163   unsigned long jresult ;
90164   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90165   std::size_t result;
90166
90167   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90168   {
90169     try {
90170       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90171     } catch (std::out_of_range& e) {
90172       {
90173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90174       };
90175     } catch (std::exception& e) {
90176       {
90177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90178       };
90179     } catch (Dali::DaliException e) {
90180       {
90181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90182       };
90183     } catch (...) {
90184       {
90185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90186       };
90187     }
90188   }
90189
90190   jresult = (unsigned long)result;
90191   return jresult;
90192 }
90193
90194
90195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90196   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90197   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90198
90199   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90200   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90201   {
90202     try {
90203       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90204     } catch (std::out_of_range& e) {
90205       {
90206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90207       };
90208     } catch (std::exception& e) {
90209       {
90210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90211       };
90212     } catch (Dali::DaliException e) {
90213       {
90214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90215       };
90216     } catch (...) {
90217       {
90218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90219       };
90220     }
90221   }
90222
90223 }
90224
90225
90226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90227   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90228   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90229
90230   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90231   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90232   {
90233     try {
90234       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90235     } catch (std::out_of_range& e) {
90236       {
90237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90238       };
90239     } catch (std::exception& e) {
90240       {
90241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90242       };
90243     } catch (Dali::DaliException e) {
90244       {
90245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90246       };
90247     } catch (...) {
90248       {
90249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90250       };
90251     }
90252   }
90253
90254 }
90255
90256
90257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90258   unsigned int jresult ;
90259   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90260   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90261   bool result;
90262
90263   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90264   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90265   if (!arg2) {
90266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90267     return 0;
90268   }
90269   {
90270     try {
90271       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90272     } catch (std::out_of_range& e) {
90273       {
90274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90275       };
90276     } catch (std::exception& e) {
90277       {
90278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90279       };
90280     } catch (Dali::DaliException e) {
90281       {
90282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90283       };
90284     } catch (...) {
90285       {
90286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90287       };
90288     }
90289   }
90290
90291   jresult = result;
90292   return jresult;
90293 }
90294
90295
90296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90297   void * jresult ;
90298   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90299
90300   {
90301     try {
90302       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90303     } catch (std::out_of_range& e) {
90304       {
90305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90306       };
90307     } catch (std::exception& e) {
90308       {
90309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90310       };
90311     } catch (Dali::DaliException e) {
90312       {
90313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90314       };
90315     } catch (...) {
90316       {
90317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90318       };
90319     }
90320   }
90321
90322   jresult = (void *)result;
90323   return jresult;
90324 }
90325
90326
90327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90328   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90329
90330   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90331   {
90332     try {
90333       delete arg1;
90334     } catch (std::out_of_range& e) {
90335       {
90336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90337       };
90338     } catch (std::exception& e) {
90339       {
90340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90341       };
90342     } catch (Dali::DaliException e) {
90343       {
90344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90345       };
90346     } catch (...) {
90347       {
90348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90349       };
90350     }
90351   }
90352
90353 }
90354
90355
90356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90357   unsigned int jresult ;
90358   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90359   bool result;
90360
90361   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90362   {
90363     try {
90364       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);
90365     } catch (std::out_of_range& e) {
90366       {
90367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90368       };
90369     } catch (std::exception& e) {
90370       {
90371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90372       };
90373     } catch (Dali::DaliException e) {
90374       {
90375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90376       };
90377     } catch (...) {
90378       {
90379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90380       };
90381     }
90382   }
90383
90384   jresult = result;
90385   return jresult;
90386 }
90387
90388
90389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90390   unsigned long jresult ;
90391   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90392   std::size_t result;
90393
90394   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90395   {
90396     try {
90397       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);
90398     } catch (std::out_of_range& e) {
90399       {
90400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90401       };
90402     } catch (std::exception& e) {
90403       {
90404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90405       };
90406     } catch (Dali::DaliException e) {
90407       {
90408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90409       };
90410     } catch (...) {
90411       {
90412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90413       };
90414     }
90415   }
90416
90417   jresult = (unsigned long)result;
90418   return jresult;
90419 }
90420
90421
90422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90423   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90424   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90425
90426   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90427   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90428   {
90429     try {
90430       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90431     } catch (std::out_of_range& e) {
90432       {
90433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90434       };
90435     } catch (std::exception& e) {
90436       {
90437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90438       };
90439     } catch (Dali::DaliException e) {
90440       {
90441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90442       };
90443     } catch (...) {
90444       {
90445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90446       };
90447     }
90448   }
90449
90450 }
90451
90452
90453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90454   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90455   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90456
90457   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90458   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90459   {
90460     try {
90461       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90462     } catch (std::out_of_range& e) {
90463       {
90464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90465       };
90466     } catch (std::exception& e) {
90467       {
90468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90469       };
90470     } catch (Dali::DaliException e) {
90471       {
90472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90473       };
90474     } catch (...) {
90475       {
90476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90477       };
90478     }
90479   }
90480
90481 }
90482
90483
90484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90485   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90486   Dali::Actor arg2 ;
90487   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90488   Dali::Actor *argp2 ;
90489
90490   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90491   argp2 = (Dali::Actor *)jarg2;
90492   if (!argp2) {
90493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90494     return ;
90495   }
90496   arg2 = *argp2;
90497   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90498   {
90499     try {
90500       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90501     } catch (std::out_of_range& e) {
90502       {
90503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90504       };
90505     } catch (std::exception& e) {
90506       {
90507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90508       };
90509     } catch (Dali::DaliException e) {
90510       {
90511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90512       };
90513     } catch (...) {
90514       {
90515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90516       };
90517     }
90518   }
90519
90520 }
90521
90522
90523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90524   void * jresult ;
90525   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90526
90527   {
90528     try {
90529       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90530     } catch (std::out_of_range& e) {
90531       {
90532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90533       };
90534     } catch (std::exception& e) {
90535       {
90536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90537       };
90538     } catch (Dali::DaliException e) {
90539       {
90540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90541       };
90542     } catch (...) {
90543       {
90544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90545       };
90546     }
90547   }
90548
90549   jresult = (void *)result;
90550   return jresult;
90551 }
90552
90553
90554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90555   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90556
90557   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90558   {
90559     try {
90560       delete arg1;
90561     } catch (std::out_of_range& e) {
90562       {
90563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90564       };
90565     } catch (std::exception& e) {
90566       {
90567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90568       };
90569     } catch (Dali::DaliException e) {
90570       {
90571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90572       };
90573     } catch (...) {
90574       {
90575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90576       };
90577     }
90578   }
90579
90580 }
90581
90582
90583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90584   unsigned int jresult ;
90585   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90586   bool result;
90587
90588   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90589   {
90590     try {
90591       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90592     } catch (std::out_of_range& e) {
90593       {
90594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90595       };
90596     } catch (std::exception& e) {
90597       {
90598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90599       };
90600     } catch (Dali::DaliException e) {
90601       {
90602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90603       };
90604     } catch (...) {
90605       {
90606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90607       };
90608     }
90609   }
90610
90611   jresult = result;
90612   return jresult;
90613 }
90614
90615
90616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90617   unsigned long jresult ;
90618   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90619   std::size_t result;
90620
90621   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90622   {
90623     try {
90624       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90625     } catch (std::out_of_range& e) {
90626       {
90627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90628       };
90629     } catch (std::exception& e) {
90630       {
90631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90632       };
90633     } catch (Dali::DaliException e) {
90634       {
90635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90636       };
90637     } catch (...) {
90638       {
90639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90640       };
90641     }
90642   }
90643
90644   jresult = (unsigned long)result;
90645   return jresult;
90646 }
90647
90648
90649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90650   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90651   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90652
90653   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90654   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90655   {
90656     try {
90657       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90658     } catch (std::out_of_range& e) {
90659       {
90660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90661       };
90662     } catch (std::exception& e) {
90663       {
90664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90665       };
90666     } catch (Dali::DaliException e) {
90667       {
90668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90669       };
90670     } catch (...) {
90671       {
90672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90673       };
90674     }
90675   }
90676
90677 }
90678
90679
90680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90681   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90682   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90683
90684   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90685   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90686   {
90687     try {
90688       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90689     } catch (std::out_of_range& e) {
90690       {
90691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90692       };
90693     } catch (std::exception& e) {
90694       {
90695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90696       };
90697     } catch (Dali::DaliException e) {
90698       {
90699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90700       };
90701     } catch (...) {
90702       {
90703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90704       };
90705     }
90706   }
90707
90708 }
90709
90710
90711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90712   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90713   Dali::Actor arg2 ;
90714   Dali::Actor arg3 ;
90715   Dali::Actor *argp2 ;
90716   Dali::Actor *argp3 ;
90717
90718   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90719   argp2 = (Dali::Actor *)jarg2;
90720   if (!argp2) {
90721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90722     return ;
90723   }
90724   arg2 = *argp2;
90725   argp3 = (Dali::Actor *)jarg3;
90726   if (!argp3) {
90727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90728     return ;
90729   }
90730   arg3 = *argp3;
90731   {
90732     try {
90733       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90734     } catch (std::out_of_range& e) {
90735       {
90736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90737       };
90738     } catch (std::exception& e) {
90739       {
90740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90741       };
90742     } catch (Dali::DaliException e) {
90743       {
90744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90745       };
90746     } catch (...) {
90747       {
90748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90749       };
90750     }
90751   }
90752
90753 }
90754
90755
90756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90757   void * jresult ;
90758   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90759
90760   {
90761     try {
90762       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90763     } catch (std::out_of_range& e) {
90764       {
90765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90766       };
90767     } catch (std::exception& e) {
90768       {
90769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90770       };
90771     } catch (Dali::DaliException e) {
90772       {
90773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90774       };
90775     } catch (...) {
90776       {
90777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90778       };
90779     }
90780   }
90781
90782   jresult = (void *)result;
90783   return jresult;
90784 }
90785
90786
90787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90788   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90789
90790   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90791   {
90792     try {
90793       delete arg1;
90794     } catch (std::out_of_range& e) {
90795       {
90796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90797       };
90798     } catch (std::exception& e) {
90799       {
90800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90801       };
90802     } catch (Dali::DaliException e) {
90803       {
90804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90805       };
90806     } catch (...) {
90807       {
90808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90809       };
90810     }
90811   }
90812
90813 }
90814
90815
90816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90817   unsigned int jresult ;
90818   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90819   bool result;
90820
90821   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90822   {
90823     try {
90824       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90825     } catch (std::out_of_range& e) {
90826       {
90827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90828       };
90829     } catch (std::exception& e) {
90830       {
90831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90832       };
90833     } catch (Dali::DaliException e) {
90834       {
90835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90836       };
90837     } catch (...) {
90838       {
90839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90840       };
90841     }
90842   }
90843
90844   jresult = result;
90845   return jresult;
90846 }
90847
90848
90849 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
90850   unsigned long jresult ;
90851   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90852   std::size_t result;
90853
90854   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90855   {
90856     try {
90857       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90858     } catch (std::out_of_range& e) {
90859       {
90860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90861       };
90862     } catch (std::exception& e) {
90863       {
90864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90865       };
90866     } catch (Dali::DaliException e) {
90867       {
90868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90869       };
90870     } catch (...) {
90871       {
90872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90873       };
90874     }
90875   }
90876
90877   jresult = (unsigned long)result;
90878   return jresult;
90879 }
90880
90881
90882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
90883   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90884   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90885
90886   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90887   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90888   {
90889     try {
90890       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
90891     } catch (std::out_of_range& e) {
90892       {
90893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90894       };
90895     } catch (std::exception& e) {
90896       {
90897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90898       };
90899     } catch (Dali::DaliException e) {
90900       {
90901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90902       };
90903     } catch (...) {
90904       {
90905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90906       };
90907     }
90908   }
90909
90910 }
90911
90912
90913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90914   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90915   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90916
90917   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90918   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90919   {
90920     try {
90921       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90922     } catch (std::out_of_range& e) {
90923       {
90924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90925       };
90926     } catch (std::exception& e) {
90927       {
90928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90929       };
90930     } catch (Dali::DaliException e) {
90931       {
90932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90933       };
90934     } catch (...) {
90935       {
90936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90937       };
90938     }
90939   }
90940
90941 }
90942
90943
90944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
90945   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90946   Dali::Actor arg2 ;
90947   bool arg3 ;
90948   Dali::Actor *argp2 ;
90949
90950   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90951   argp2 = (Dali::Actor *)jarg2;
90952   if (!argp2) {
90953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90954     return ;
90955   }
90956   arg2 = *argp2;
90957   arg3 = jarg3 ? true : false;
90958   {
90959     try {
90960       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90961     } catch (std::out_of_range& e) {
90962       {
90963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90964       };
90965     } catch (std::exception& e) {
90966       {
90967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90968       };
90969     } catch (Dali::DaliException e) {
90970       {
90971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90972       };
90973     } catch (...) {
90974       {
90975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90976       };
90977     }
90978   }
90979
90980 }
90981
90982
90983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90984   void * jresult ;
90985   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90986
90987   {
90988     try {
90989       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90990     } catch (std::out_of_range& e) {
90991       {
90992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90993       };
90994     } catch (std::exception& e) {
90995       {
90996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90997       };
90998     } catch (Dali::DaliException e) {
90999       {
91000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91001       };
91002     } catch (...) {
91003       {
91004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91005       };
91006     }
91007   }
91008
91009   jresult = (void *)result;
91010   return jresult;
91011 }
91012
91013
91014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
91015   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91016
91017   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91018   {
91019     try {
91020       delete arg1;
91021     } catch (std::out_of_range& e) {
91022       {
91023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91024       };
91025     } catch (std::exception& e) {
91026       {
91027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91028       };
91029     } catch (Dali::DaliException e) {
91030       {
91031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91032       };
91033     } catch (...) {
91034       {
91035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91036       };
91037     }
91038   }
91039
91040 }
91041
91042
91043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
91044   unsigned int jresult ;
91045   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91046   bool result;
91047
91048   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91049   {
91050     try {
91051       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);
91052     } catch (std::out_of_range& e) {
91053       {
91054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91055       };
91056     } catch (std::exception& e) {
91057       {
91058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91059       };
91060     } catch (Dali::DaliException e) {
91061       {
91062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91063       };
91064     } catch (...) {
91065       {
91066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91067       };
91068     }
91069   }
91070
91071   jresult = result;
91072   return jresult;
91073 }
91074
91075
91076 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
91077   unsigned long jresult ;
91078   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91079   std::size_t result;
91080
91081   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91082   {
91083     try {
91084       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);
91085     } catch (std::out_of_range& e) {
91086       {
91087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91088       };
91089     } catch (std::exception& e) {
91090       {
91091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91092       };
91093     } catch (Dali::DaliException e) {
91094       {
91095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91096       };
91097     } catch (...) {
91098       {
91099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91100       };
91101     }
91102   }
91103
91104   jresult = (unsigned long)result;
91105   return jresult;
91106 }
91107
91108
91109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
91110   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91111   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91112
91113   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91114   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91115   {
91116     try {
91117       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
91118     } catch (std::out_of_range& e) {
91119       {
91120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91121       };
91122     } catch (std::exception& e) {
91123       {
91124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91125       };
91126     } catch (Dali::DaliException e) {
91127       {
91128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91129       };
91130     } catch (...) {
91131       {
91132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91133       };
91134     }
91135   }
91136
91137 }
91138
91139
91140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91141   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91142   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91143
91144   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91145   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91146   {
91147     try {
91148       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
91149     } catch (std::out_of_range& e) {
91150       {
91151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91152       };
91153     } catch (std::exception& e) {
91154       {
91155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91156       };
91157     } catch (Dali::DaliException e) {
91158       {
91159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91160       };
91161     } catch (...) {
91162       {
91163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91164       };
91165     }
91166   }
91167
91168 }
91169
91170
91171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91172   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91173   Dali::Toolkit::StyleManager arg2 ;
91174   Dali::StyleChange::Type arg3 ;
91175   Dali::Toolkit::StyleManager *argp2 ;
91176
91177   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91178   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91179   if (!argp2) {
91180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91181     return ;
91182   }
91183   arg2 = *argp2;
91184   arg3 = (Dali::StyleChange::Type)jarg3;
91185   {
91186     try {
91187       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91188     } catch (std::out_of_range& e) {
91189       {
91190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91191       };
91192     } catch (std::exception& e) {
91193       {
91194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91195       };
91196     } catch (Dali::DaliException e) {
91197       {
91198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91199       };
91200     } catch (...) {
91201       {
91202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91203       };
91204     }
91205   }
91206
91207 }
91208
91209
91210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91211   void * jresult ;
91212   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91213
91214   {
91215     try {
91216       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91217     } catch (std::out_of_range& e) {
91218       {
91219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91220       };
91221     } catch (std::exception& e) {
91222       {
91223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91224       };
91225     } catch (Dali::DaliException e) {
91226       {
91227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91228       };
91229     } catch (...) {
91230       {
91231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91232       };
91233     }
91234   }
91235
91236   jresult = (void *)result;
91237   return jresult;
91238 }
91239
91240
91241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91242   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91243
91244   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91245   {
91246     try {
91247       delete arg1;
91248     } catch (std::out_of_range& e) {
91249       {
91250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91251       };
91252     } catch (std::exception& e) {
91253       {
91254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91255       };
91256     } catch (Dali::DaliException e) {
91257       {
91258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91259       };
91260     } catch (...) {
91261       {
91262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91263       };
91264     }
91265   }
91266
91267 }
91268
91269
91270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91271   unsigned int jresult ;
91272   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91273   bool result;
91274
91275   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91276   {
91277     try {
91278       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91279     } catch (std::out_of_range& e) {
91280       {
91281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91282       };
91283     } catch (std::exception& e) {
91284       {
91285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91286       };
91287     } catch (Dali::DaliException e) {
91288       {
91289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91290       };
91291     } catch (...) {
91292       {
91293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91294       };
91295     }
91296   }
91297
91298   jresult = result;
91299   return jresult;
91300 }
91301
91302
91303 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91304   unsigned long jresult ;
91305   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91306   std::size_t result;
91307
91308   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91309   {
91310     try {
91311       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91312     } catch (std::out_of_range& e) {
91313       {
91314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91315       };
91316     } catch (std::exception& e) {
91317       {
91318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91319       };
91320     } catch (Dali::DaliException e) {
91321       {
91322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91323       };
91324     } catch (...) {
91325       {
91326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91327       };
91328     }
91329   }
91330
91331   jresult = (unsigned long)result;
91332   return jresult;
91333 }
91334
91335
91336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91337   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91338   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91339
91340   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91341   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91342   {
91343     try {
91344       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91345     } catch (std::out_of_range& e) {
91346       {
91347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91348       };
91349     } catch (std::exception& e) {
91350       {
91351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91352       };
91353     } catch (Dali::DaliException e) {
91354       {
91355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91356       };
91357     } catch (...) {
91358       {
91359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91360       };
91361     }
91362   }
91363
91364 }
91365
91366
91367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91368   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91369   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91370
91371   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91372   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91373   {
91374     try {
91375       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91376     } catch (std::out_of_range& e) {
91377       {
91378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91379       };
91380     } catch (std::exception& e) {
91381       {
91382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91383       };
91384     } catch (Dali::DaliException e) {
91385       {
91386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91387       };
91388     } catch (...) {
91389       {
91390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91391       };
91392     }
91393   }
91394
91395 }
91396
91397
91398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91399   unsigned int jresult ;
91400   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91401   Dali::Toolkit::Button arg2 ;
91402   Dali::Toolkit::Button *argp2 ;
91403   bool result;
91404
91405   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91406   argp2 = (Dali::Toolkit::Button *)jarg2;
91407   if (!argp2) {
91408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91409     return 0;
91410   }
91411   arg2 = *argp2;
91412   {
91413     try {
91414       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91415     } catch (std::out_of_range& e) {
91416       {
91417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91418       };
91419     } catch (std::exception& e) {
91420       {
91421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91422       };
91423     } catch (Dali::DaliException e) {
91424       {
91425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91426       };
91427     } catch (...) {
91428       {
91429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91430       };
91431     }
91432   }
91433
91434   jresult = result;
91435   return jresult;
91436 }
91437
91438
91439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91440   void * jresult ;
91441   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91442
91443   {
91444     try {
91445       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91446     } catch (std::out_of_range& e) {
91447       {
91448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91449       };
91450     } catch (std::exception& e) {
91451       {
91452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91453       };
91454     } catch (Dali::DaliException e) {
91455       {
91456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91457       };
91458     } catch (...) {
91459       {
91460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91461       };
91462     }
91463   }
91464
91465   jresult = (void *)result;
91466   return jresult;
91467 }
91468
91469
91470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91471   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91472
91473   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91474   {
91475     try {
91476       delete arg1;
91477     } catch (std::out_of_range& e) {
91478       {
91479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91480       };
91481     } catch (std::exception& e) {
91482       {
91483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91484       };
91485     } catch (Dali::DaliException e) {
91486       {
91487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91488       };
91489     } catch (...) {
91490       {
91491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91492       };
91493     }
91494   }
91495
91496 }
91497
91498
91499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91500   unsigned int jresult ;
91501   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91502   bool result;
91503
91504   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91505   {
91506     try {
91507       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91508     } catch (std::out_of_range& e) {
91509       {
91510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91511       };
91512     } catch (std::exception& e) {
91513       {
91514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91515       };
91516     } catch (Dali::DaliException e) {
91517       {
91518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91519       };
91520     } catch (...) {
91521       {
91522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91523       };
91524     }
91525   }
91526
91527   jresult = result;
91528   return jresult;
91529 }
91530
91531
91532 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91533   unsigned long jresult ;
91534   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91535   std::size_t result;
91536
91537   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91538   {
91539     try {
91540       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91541     } catch (std::out_of_range& e) {
91542       {
91543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91544       };
91545     } catch (std::exception& e) {
91546       {
91547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91548       };
91549     } catch (Dali::DaliException e) {
91550       {
91551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91552       };
91553     } catch (...) {
91554       {
91555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91556       };
91557     }
91558   }
91559
91560   jresult = (unsigned long)result;
91561   return jresult;
91562 }
91563
91564
91565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91566   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91567   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91568
91569   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91570   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91571   {
91572     try {
91573       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91574     } catch (std::out_of_range& e) {
91575       {
91576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91577       };
91578     } catch (std::exception& e) {
91579       {
91580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91581       };
91582     } catch (Dali::DaliException e) {
91583       {
91584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91585       };
91586     } catch (...) {
91587       {
91588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91589       };
91590     }
91591   }
91592
91593 }
91594
91595
91596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91597   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91598   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91599
91600   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91601   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91602   {
91603     try {
91604       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91605     } catch (std::out_of_range& e) {
91606       {
91607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91608       };
91609     } catch (std::exception& e) {
91610       {
91611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91612       };
91613     } catch (Dali::DaliException e) {
91614       {
91615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91616       };
91617     } catch (...) {
91618       {
91619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91620       };
91621     }
91622   }
91623
91624 }
91625
91626
91627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91628   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91629   Dali::Toolkit::GaussianBlurView arg2 ;
91630   Dali::Toolkit::GaussianBlurView *argp2 ;
91631
91632   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91633   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91634   if (!argp2) {
91635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91636     return ;
91637   }
91638   arg2 = *argp2;
91639   {
91640     try {
91641       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91642     } catch (std::out_of_range& e) {
91643       {
91644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91645       };
91646     } catch (std::exception& e) {
91647       {
91648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91649       };
91650     } catch (Dali::DaliException e) {
91651       {
91652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91653       };
91654     } catch (...) {
91655       {
91656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91657       };
91658     }
91659   }
91660
91661 }
91662
91663
91664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91665   void * jresult ;
91666   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91667
91668   {
91669     try {
91670       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91671     } catch (std::out_of_range& e) {
91672       {
91673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91674       };
91675     } catch (std::exception& e) {
91676       {
91677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91678       };
91679     } catch (Dali::DaliException e) {
91680       {
91681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91682       };
91683     } catch (...) {
91684       {
91685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91686       };
91687     }
91688   }
91689
91690   jresult = (void *)result;
91691   return jresult;
91692 }
91693
91694
91695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91696   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91697
91698   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91699   {
91700     try {
91701       delete arg1;
91702     } catch (std::out_of_range& e) {
91703       {
91704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91705       };
91706     } catch (std::exception& e) {
91707       {
91708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91709       };
91710     } catch (Dali::DaliException e) {
91711       {
91712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91713       };
91714     } catch (...) {
91715       {
91716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91717       };
91718     }
91719   }
91720
91721 }
91722
91723
91724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91725   unsigned int jresult ;
91726   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91727   bool result;
91728
91729   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91730   {
91731     try {
91732       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);
91733     } catch (std::out_of_range& e) {
91734       {
91735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91736       };
91737     } catch (std::exception& e) {
91738       {
91739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91740       };
91741     } catch (Dali::DaliException e) {
91742       {
91743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91744       };
91745     } catch (...) {
91746       {
91747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91748       };
91749     }
91750   }
91751
91752   jresult = result;
91753   return jresult;
91754 }
91755
91756
91757 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91758   unsigned long jresult ;
91759   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91760   std::size_t result;
91761
91762   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91763   {
91764     try {
91765       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);
91766     } catch (std::out_of_range& e) {
91767       {
91768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91769       };
91770     } catch (std::exception& e) {
91771       {
91772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91773       };
91774     } catch (Dali::DaliException e) {
91775       {
91776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91777       };
91778     } catch (...) {
91779       {
91780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91781       };
91782     }
91783   }
91784
91785   jresult = (unsigned long)result;
91786   return jresult;
91787 }
91788
91789
91790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91791   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91792   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91793
91794   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91795   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91796   {
91797     try {
91798       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91799     } catch (std::out_of_range& e) {
91800       {
91801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91802       };
91803     } catch (std::exception& e) {
91804       {
91805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91806       };
91807     } catch (Dali::DaliException e) {
91808       {
91809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91810       };
91811     } catch (...) {
91812       {
91813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91814       };
91815     }
91816   }
91817
91818 }
91819
91820
91821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91822   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91823   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91824
91825   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91826   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91827   {
91828     try {
91829       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91830     } catch (std::out_of_range& e) {
91831       {
91832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91833       };
91834     } catch (std::exception& e) {
91835       {
91836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91837       };
91838     } catch (Dali::DaliException e) {
91839       {
91840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91841       };
91842     } catch (...) {
91843       {
91844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91845       };
91846     }
91847   }
91848
91849 }
91850
91851
91852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
91853   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91854   Dali::Toolkit::PageTurnView arg2 ;
91855   unsigned int arg3 ;
91856   bool arg4 ;
91857   Dali::Toolkit::PageTurnView *argp2 ;
91858
91859   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91860   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91861   if (!argp2) {
91862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91863     return ;
91864   }
91865   arg2 = *argp2;
91866   arg3 = (unsigned int)jarg3;
91867   arg4 = jarg4 ? true : false;
91868   {
91869     try {
91870       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91871     } catch (std::out_of_range& e) {
91872       {
91873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91874       };
91875     } catch (std::exception& e) {
91876       {
91877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91878       };
91879     } catch (Dali::DaliException e) {
91880       {
91881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91882       };
91883     } catch (...) {
91884       {
91885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91886       };
91887     }
91888   }
91889
91890 }
91891
91892
91893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
91894   void * jresult ;
91895   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
91896
91897   {
91898     try {
91899       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
91900     } catch (std::out_of_range& e) {
91901       {
91902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91903       };
91904     } catch (std::exception& e) {
91905       {
91906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91907       };
91908     } catch (Dali::DaliException e) {
91909       {
91910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91911       };
91912     } catch (...) {
91913       {
91914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91915       };
91916     }
91917   }
91918
91919   jresult = (void *)result;
91920   return jresult;
91921 }
91922
91923
91924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
91925   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91926
91927   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91928   {
91929     try {
91930       delete arg1;
91931     } catch (std::out_of_range& e) {
91932       {
91933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91934       };
91935     } catch (std::exception& e) {
91936       {
91937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91938       };
91939     } catch (Dali::DaliException e) {
91940       {
91941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91942       };
91943     } catch (...) {
91944       {
91945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91946       };
91947     }
91948   }
91949
91950 }
91951
91952
91953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
91954   unsigned int jresult ;
91955   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91956   bool result;
91957
91958   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91959   {
91960     try {
91961       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91962     } catch (std::out_of_range& e) {
91963       {
91964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91965       };
91966     } catch (std::exception& e) {
91967       {
91968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91969       };
91970     } catch (Dali::DaliException e) {
91971       {
91972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91973       };
91974     } catch (...) {
91975       {
91976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91977       };
91978     }
91979   }
91980
91981   jresult = result;
91982   return jresult;
91983 }
91984
91985
91986 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
91987   unsigned long jresult ;
91988   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91989   std::size_t result;
91990
91991   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91992   {
91993     try {
91994       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91995     } catch (std::out_of_range& e) {
91996       {
91997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91998       };
91999     } catch (std::exception& e) {
92000       {
92001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92002       };
92003     } catch (Dali::DaliException e) {
92004       {
92005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92006       };
92007     } catch (...) {
92008       {
92009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92010       };
92011     }
92012   }
92013
92014   jresult = (unsigned long)result;
92015   return jresult;
92016 }
92017
92018
92019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
92020   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92021   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92022
92023   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92024   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92025   {
92026     try {
92027       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
92028     } catch (std::out_of_range& e) {
92029       {
92030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92031       };
92032     } catch (std::exception& e) {
92033       {
92034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92035       };
92036     } catch (Dali::DaliException e) {
92037       {
92038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92039       };
92040     } catch (...) {
92041       {
92042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92043       };
92044     }
92045   }
92046
92047 }
92048
92049
92050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
92051   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92052   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92053
92054   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92055   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92056   {
92057     try {
92058       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
92059     } catch (std::out_of_range& e) {
92060       {
92061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92062       };
92063     } catch (std::exception& e) {
92064       {
92065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92066       };
92067     } catch (Dali::DaliException e) {
92068       {
92069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92070       };
92071     } catch (...) {
92072       {
92073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92074       };
92075     }
92076   }
92077
92078 }
92079
92080
92081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
92082   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92083   Dali::Toolkit::PageTurnView arg2 ;
92084   Dali::Toolkit::PageTurnView *argp2 ;
92085
92086   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92087   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92088   if (!argp2) {
92089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92090     return ;
92091   }
92092   arg2 = *argp2;
92093   {
92094     try {
92095       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
92096     } catch (std::out_of_range& e) {
92097       {
92098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92099       };
92100     } catch (std::exception& e) {
92101       {
92102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92103       };
92104     } catch (Dali::DaliException e) {
92105       {
92106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92107       };
92108     } catch (...) {
92109       {
92110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92111       };
92112     }
92113   }
92114
92115 }
92116
92117
92118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
92119   void * jresult ;
92120   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
92121
92122   {
92123     try {
92124       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
92125     } catch (std::out_of_range& e) {
92126       {
92127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92128       };
92129     } catch (std::exception& e) {
92130       {
92131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92132       };
92133     } catch (Dali::DaliException e) {
92134       {
92135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92136       };
92137     } catch (...) {
92138       {
92139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92140       };
92141     }
92142   }
92143
92144   jresult = (void *)result;
92145   return jresult;
92146 }
92147
92148
92149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
92150   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92151
92152   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92153   {
92154     try {
92155       delete arg1;
92156     } catch (std::out_of_range& e) {
92157       {
92158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92159       };
92160     } catch (std::exception& e) {
92161       {
92162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92163       };
92164     } catch (Dali::DaliException e) {
92165       {
92166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92167       };
92168     } catch (...) {
92169       {
92170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92171       };
92172     }
92173   }
92174
92175 }
92176
92177
92178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92179   unsigned int jresult ;
92180   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92181   bool result;
92182
92183   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92184   {
92185     try {
92186       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);
92187     } catch (std::out_of_range& e) {
92188       {
92189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92190       };
92191     } catch (std::exception& e) {
92192       {
92193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92194       };
92195     } catch (Dali::DaliException e) {
92196       {
92197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92198       };
92199     } catch (...) {
92200       {
92201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92202       };
92203     }
92204   }
92205
92206   jresult = result;
92207   return jresult;
92208 }
92209
92210
92211 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92212   unsigned long jresult ;
92213   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92214   std::size_t result;
92215
92216   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92217   {
92218     try {
92219       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);
92220     } catch (std::out_of_range& e) {
92221       {
92222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92223       };
92224     } catch (std::exception& e) {
92225       {
92226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92227       };
92228     } catch (Dali::DaliException e) {
92229       {
92230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92231       };
92232     } catch (...) {
92233       {
92234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92235       };
92236     }
92237   }
92238
92239   jresult = (unsigned long)result;
92240   return jresult;
92241 }
92242
92243
92244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92245   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92246   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92247
92248   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92249   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92250   {
92251     try {
92252       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92253     } catch (std::out_of_range& e) {
92254       {
92255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92256       };
92257     } catch (std::exception& e) {
92258       {
92259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92260       };
92261     } catch (Dali::DaliException e) {
92262       {
92263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92264       };
92265     } catch (...) {
92266       {
92267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92268       };
92269     }
92270   }
92271
92272 }
92273
92274
92275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92276   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92277   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92278
92279   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92280   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92281   {
92282     try {
92283       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92284     } catch (std::out_of_range& e) {
92285       {
92286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92287       };
92288     } catch (std::exception& e) {
92289       {
92290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92291       };
92292     } catch (Dali::DaliException e) {
92293       {
92294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92295       };
92296     } catch (...) {
92297       {
92298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92299       };
92300     }
92301   }
92302
92303 }
92304
92305
92306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92307   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92308   Dali::Toolkit::ProgressBar arg2 ;
92309   float arg3 ;
92310   float arg4 ;
92311   Dali::Toolkit::ProgressBar *argp2 ;
92312
92313   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92314   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92315   if (!argp2) {
92316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92317     return ;
92318   }
92319   arg2 = *argp2;
92320   arg3 = (float)jarg3;
92321   arg4 = (float)jarg4;
92322   {
92323     try {
92324       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92325     } catch (std::out_of_range& e) {
92326       {
92327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92328       };
92329     } catch (std::exception& e) {
92330       {
92331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92332       };
92333     } catch (Dali::DaliException e) {
92334       {
92335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92336       };
92337     } catch (...) {
92338       {
92339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92340       };
92341     }
92342   }
92343
92344 }
92345
92346
92347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92348   void * jresult ;
92349   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92350
92351   {
92352     try {
92353       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92354     } catch (std::out_of_range& e) {
92355       {
92356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92357       };
92358     } catch (std::exception& e) {
92359       {
92360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92361       };
92362     } catch (Dali::DaliException e) {
92363       {
92364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92365       };
92366     } catch (...) {
92367       {
92368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92369       };
92370     }
92371   }
92372
92373   jresult = (void *)result;
92374   return jresult;
92375 }
92376
92377
92378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92379   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92380
92381   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92382   {
92383     try {
92384       delete arg1;
92385     } catch (std::out_of_range& e) {
92386       {
92387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92388       };
92389     } catch (std::exception& e) {
92390       {
92391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92392       };
92393     } catch (Dali::DaliException e) {
92394       {
92395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92396       };
92397     } catch (...) {
92398       {
92399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92400       };
92401     }
92402   }
92403
92404 }
92405
92406
92407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92408   unsigned int jresult ;
92409   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92410   bool result;
92411
92412   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92413   {
92414     try {
92415       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);
92416     } catch (std::out_of_range& e) {
92417       {
92418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92419       };
92420     } catch (std::exception& e) {
92421       {
92422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92423       };
92424     } catch (Dali::DaliException e) {
92425       {
92426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92427       };
92428     } catch (...) {
92429       {
92430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92431       };
92432     }
92433   }
92434
92435   jresult = result;
92436   return jresult;
92437 }
92438
92439
92440 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92441   unsigned long jresult ;
92442   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92443   std::size_t result;
92444
92445   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92446   {
92447     try {
92448       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);
92449     } catch (std::out_of_range& e) {
92450       {
92451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92452       };
92453     } catch (std::exception& e) {
92454       {
92455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92456       };
92457     } catch (Dali::DaliException e) {
92458       {
92459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92460       };
92461     } catch (...) {
92462       {
92463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92464       };
92465     }
92466   }
92467
92468   jresult = (unsigned long)result;
92469   return jresult;
92470 }
92471
92472
92473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92474   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92475   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92476
92477   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92478   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92479   {
92480     try {
92481       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92482     } catch (std::out_of_range& e) {
92483       {
92484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92485       };
92486     } catch (std::exception& e) {
92487       {
92488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92489       };
92490     } catch (Dali::DaliException e) {
92491       {
92492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92493       };
92494     } catch (...) {
92495       {
92496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92497       };
92498     }
92499   }
92500
92501 }
92502
92503
92504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92505   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92506   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92507
92508   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92509   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92510   {
92511     try {
92512       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92513     } catch (std::out_of_range& e) {
92514       {
92515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92516       };
92517     } catch (std::exception& e) {
92518       {
92519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92520       };
92521     } catch (Dali::DaliException e) {
92522       {
92523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92524       };
92525     } catch (...) {
92526       {
92527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92528       };
92529     }
92530   }
92531
92532 }
92533
92534
92535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92536   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92537   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92538
92539   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92540   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92541   if (!arg2) {
92542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92543     return ;
92544   }
92545   {
92546     try {
92547       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92548     } catch (std::out_of_range& e) {
92549       {
92550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92551       };
92552     } catch (std::exception& e) {
92553       {
92554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92555       };
92556     } catch (Dali::DaliException e) {
92557       {
92558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92559       };
92560     } catch (...) {
92561       {
92562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92563       };
92564     }
92565   }
92566
92567 }
92568
92569
92570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92571   void * jresult ;
92572   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92573
92574   {
92575     try {
92576       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92577     } catch (std::out_of_range& e) {
92578       {
92579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92580       };
92581     } catch (std::exception& e) {
92582       {
92583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92584       };
92585     } catch (Dali::DaliException e) {
92586       {
92587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92588       };
92589     } catch (...) {
92590       {
92591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92592       };
92593     }
92594   }
92595
92596   jresult = (void *)result;
92597   return jresult;
92598 }
92599
92600
92601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92602   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92603
92604   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92605   {
92606     try {
92607       delete arg1;
92608     } catch (std::out_of_range& e) {
92609       {
92610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92611       };
92612     } catch (std::exception& e) {
92613       {
92614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92615       };
92616     } catch (Dali::DaliException e) {
92617       {
92618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92619       };
92620     } catch (...) {
92621       {
92622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92623       };
92624     }
92625   }
92626
92627 }
92628
92629
92630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92631   unsigned int jresult ;
92632   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92633   bool result;
92634
92635   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92636   {
92637     try {
92638       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92639     } catch (std::out_of_range& e) {
92640       {
92641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92642       };
92643     } catch (std::exception& e) {
92644       {
92645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92646       };
92647     } catch (Dali::DaliException e) {
92648       {
92649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92650       };
92651     } catch (...) {
92652       {
92653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92654       };
92655     }
92656   }
92657
92658   jresult = result;
92659   return jresult;
92660 }
92661
92662
92663 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92664   unsigned long jresult ;
92665   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92666   std::size_t result;
92667
92668   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92669   {
92670     try {
92671       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92672     } catch (std::out_of_range& e) {
92673       {
92674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92675       };
92676     } catch (std::exception& e) {
92677       {
92678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92679       };
92680     } catch (Dali::DaliException e) {
92681       {
92682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92683       };
92684     } catch (...) {
92685       {
92686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92687       };
92688     }
92689   }
92690
92691   jresult = (unsigned long)result;
92692   return jresult;
92693 }
92694
92695
92696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92697   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92698   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92699
92700   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92701   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92702   {
92703     try {
92704       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92705     } catch (std::out_of_range& e) {
92706       {
92707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92708       };
92709     } catch (std::exception& e) {
92710       {
92711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92712       };
92713     } catch (Dali::DaliException e) {
92714       {
92715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92716       };
92717     } catch (...) {
92718       {
92719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92720       };
92721     }
92722   }
92723
92724 }
92725
92726
92727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92728   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92729   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92730
92731   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92732   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92733   {
92734     try {
92735       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92736     } catch (std::out_of_range& e) {
92737       {
92738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92739       };
92740     } catch (std::exception& e) {
92741       {
92742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92743       };
92744     } catch (Dali::DaliException e) {
92745       {
92746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92747       };
92748     } catch (...) {
92749       {
92750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92751       };
92752     }
92753   }
92754
92755 }
92756
92757
92758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92759   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92760   Dali::Vector2 *arg2 = 0 ;
92761
92762   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92763   arg2 = (Dali::Vector2 *)jarg2;
92764   if (!arg2) {
92765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92766     return ;
92767   }
92768   {
92769     try {
92770       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92771     } catch (std::out_of_range& e) {
92772       {
92773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92774       };
92775     } catch (std::exception& e) {
92776       {
92777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92778       };
92779     } catch (Dali::DaliException e) {
92780       {
92781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92782       };
92783     } catch (...) {
92784       {
92785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92786       };
92787     }
92788   }
92789
92790 }
92791
92792
92793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92794   void * jresult ;
92795   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92796
92797   {
92798     try {
92799       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92800     } catch (std::out_of_range& e) {
92801       {
92802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92803       };
92804     } catch (std::exception& e) {
92805       {
92806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92807       };
92808     } catch (Dali::DaliException e) {
92809       {
92810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92811       };
92812     } catch (...) {
92813       {
92814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92815       };
92816     }
92817   }
92818
92819   jresult = (void *)result;
92820   return jresult;
92821 }
92822
92823
92824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
92825   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92826
92827   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92828   {
92829     try {
92830       delete arg1;
92831     } catch (std::out_of_range& e) {
92832       {
92833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92834       };
92835     } catch (std::exception& e) {
92836       {
92837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92838       };
92839     } catch (Dali::DaliException e) {
92840       {
92841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92842       };
92843     } catch (...) {
92844       {
92845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92846       };
92847     }
92848   }
92849
92850 }
92851
92852
92853
92854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92855   unsigned int jresult ;
92856   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92857   bool result;
92858
92859   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92860   {
92861     try {
92862       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);
92863     } catch (std::out_of_range& e) {
92864       {
92865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92866       };
92867     } catch (std::exception& e) {
92868       {
92869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92870       };
92871     } catch (Dali::DaliException e) {
92872       {
92873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92874       };
92875     } catch (...) {
92876       {
92877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92878       };
92879     }
92880   }
92881
92882   jresult = result;
92883   return jresult;
92884 }
92885
92886
92887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92888   unsigned long jresult ;
92889   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92890   std::size_t result;
92891
92892   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92893   {
92894     try {
92895       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);
92896     } catch (std::out_of_range& e) {
92897       {
92898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92899       };
92900     } catch (std::exception& e) {
92901       {
92902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92903       };
92904     } catch (Dali::DaliException e) {
92905       {
92906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92907       };
92908     } catch (...) {
92909       {
92910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92911       };
92912     }
92913   }
92914
92915   jresult = (unsigned long)result;
92916   return jresult;
92917 }
92918
92919
92920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92921   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92922   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92923
92924   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92925   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92926   {
92927     try {
92928       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92929     } catch (std::out_of_range& e) {
92930       {
92931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92932       };
92933     } catch (std::exception& e) {
92934       {
92935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92936       };
92937     } catch (Dali::DaliException e) {
92938       {
92939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92940       };
92941     } catch (...) {
92942       {
92943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92944       };
92945     }
92946   }
92947
92948 }
92949
92950
92951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92952   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92953   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92954
92955   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92956   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92957   {
92958     try {
92959       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92960     } catch (std::out_of_range& e) {
92961       {
92962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92963       };
92964     } catch (std::exception& e) {
92965       {
92966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92967       };
92968     } catch (Dali::DaliException e) {
92969       {
92970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92971       };
92972     } catch (...) {
92973       {
92974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92975       };
92976     }
92977   }
92978
92979 }
92980
92981
92982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92983   unsigned int jresult ;
92984   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92985   Dali::Toolkit::Control arg2 ;
92986   Dali::KeyEvent *arg3 = 0 ;
92987   Dali::Toolkit::Control *argp2 ;
92988   bool result;
92989
92990   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92991   argp2 = (Dali::Toolkit::Control *)jarg2;
92992   if (!argp2) {
92993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92994     return 0;
92995   }
92996   arg2 = *argp2;
92997   arg3 = (Dali::KeyEvent *)jarg3;
92998   if (!arg3) {
92999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
93000     return 0;
93001   }
93002   {
93003     try {
93004       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);
93005     } catch (std::out_of_range& e) {
93006       {
93007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93008       };
93009     } catch (std::exception& e) {
93010       {
93011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93012       };
93013     } catch (Dali::DaliException e) {
93014       {
93015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93016       };
93017     } catch (...) {
93018       {
93019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93020       };
93021     }
93022   }
93023
93024   jresult = result;
93025   return jresult;
93026 }
93027
93028
93029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
93030   void * jresult ;
93031   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
93032
93033   {
93034     try {
93035       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
93036     } catch (std::out_of_range& e) {
93037       {
93038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93039       };
93040     } catch (std::exception& e) {
93041       {
93042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93043       };
93044     } catch (Dali::DaliException e) {
93045       {
93046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93047       };
93048     } catch (...) {
93049       {
93050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93051       };
93052     }
93053   }
93054
93055   jresult = (void *)result;
93056   return jresult;
93057 }
93058
93059
93060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
93061   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93062
93063   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93064   {
93065     try {
93066       delete arg1;
93067     } catch (std::out_of_range& e) {
93068       {
93069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93070       };
93071     } catch (std::exception& e) {
93072       {
93073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93074       };
93075     } catch (Dali::DaliException e) {
93076       {
93077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93078       };
93079     } catch (...) {
93080       {
93081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93082       };
93083     }
93084   }
93085
93086 }
93087
93088
93089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
93090   unsigned int jresult ;
93091   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93092   bool result;
93093
93094   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93095   {
93096     try {
93097       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93098     } catch (std::out_of_range& e) {
93099       {
93100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93101       };
93102     } catch (std::exception& e) {
93103       {
93104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93105       };
93106     } catch (Dali::DaliException e) {
93107       {
93108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93109       };
93110     } catch (...) {
93111       {
93112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93113       };
93114     }
93115   }
93116
93117   jresult = result;
93118   return jresult;
93119 }
93120
93121
93122 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
93123   unsigned long jresult ;
93124   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93125   std::size_t result;
93126
93127   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93128   {
93129     try {
93130       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93131     } catch (std::out_of_range& e) {
93132       {
93133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93134       };
93135     } catch (std::exception& e) {
93136       {
93137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93138       };
93139     } catch (Dali::DaliException e) {
93140       {
93141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93142       };
93143     } catch (...) {
93144       {
93145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93146       };
93147     }
93148   }
93149
93150   jresult = (unsigned long)result;
93151   return jresult;
93152 }
93153
93154
93155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
93156   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93157   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93158
93159   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93160   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93161   {
93162     try {
93163       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93164     } catch (std::out_of_range& e) {
93165       {
93166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93167       };
93168     } catch (std::exception& e) {
93169       {
93170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93171       };
93172     } catch (Dali::DaliException e) {
93173       {
93174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93175       };
93176     } catch (...) {
93177       {
93178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93179       };
93180     }
93181   }
93182
93183 }
93184
93185
93186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93187   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93188   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93189
93190   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93191   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93192   {
93193     try {
93194       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93195     } catch (std::out_of_range& e) {
93196       {
93197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93198       };
93199     } catch (std::exception& e) {
93200       {
93201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93202       };
93203     } catch (Dali::DaliException e) {
93204       {
93205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93206       };
93207     } catch (...) {
93208       {
93209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93210       };
93211     }
93212   }
93213
93214 }
93215
93216
93217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93218   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93219   Dali::Toolkit::Control arg2 ;
93220   Dali::Toolkit::Control *argp2 ;
93221
93222   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93223   argp2 = (Dali::Toolkit::Control *)jarg2;
93224   if (!argp2) {
93225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93226     return ;
93227   }
93228   arg2 = *argp2;
93229   {
93230     try {
93231       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93232     } catch (std::out_of_range& e) {
93233       {
93234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93235       };
93236     } catch (std::exception& e) {
93237       {
93238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93239       };
93240     } catch (Dali::DaliException e) {
93241       {
93242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93243       };
93244     } catch (...) {
93245       {
93246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93247       };
93248     }
93249   }
93250
93251 }
93252
93253
93254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93255   void * jresult ;
93256   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93257
93258   {
93259     try {
93260       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93261     } catch (std::out_of_range& e) {
93262       {
93263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93264       };
93265     } catch (std::exception& e) {
93266       {
93267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93268       };
93269     } catch (Dali::DaliException e) {
93270       {
93271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93272       };
93273     } catch (...) {
93274       {
93275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93276       };
93277     }
93278   }
93279
93280   jresult = (void *)result;
93281   return jresult;
93282 }
93283
93284
93285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93286   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93287
93288   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93289   {
93290     try {
93291       delete arg1;
93292     } catch (std::out_of_range& e) {
93293       {
93294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93295       };
93296     } catch (std::exception& e) {
93297       {
93298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93299       };
93300     } catch (Dali::DaliException e) {
93301       {
93302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93303       };
93304     } catch (...) {
93305       {
93306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93307       };
93308     }
93309   }
93310
93311 }
93312
93313
93314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93315   unsigned int jresult ;
93316   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93317   bool result;
93318
93319   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93320   {
93321     try {
93322       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93323     } catch (std::out_of_range& e) {
93324       {
93325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93326       };
93327     } catch (std::exception& e) {
93328       {
93329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93330       };
93331     } catch (Dali::DaliException e) {
93332       {
93333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93334       };
93335     } catch (...) {
93336       {
93337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93338       };
93339     }
93340   }
93341
93342   jresult = result;
93343   return jresult;
93344 }
93345
93346
93347 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93348   unsigned long jresult ;
93349   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93350   std::size_t result;
93351
93352   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93353   {
93354     try {
93355       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93356     } catch (std::out_of_range& e) {
93357       {
93358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93359       };
93360     } catch (std::exception& e) {
93361       {
93362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93363       };
93364     } catch (Dali::DaliException e) {
93365       {
93366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93367       };
93368     } catch (...) {
93369       {
93370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93371       };
93372     }
93373   }
93374
93375   jresult = (unsigned long)result;
93376   return jresult;
93377 }
93378
93379
93380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93381   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93382   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93383
93384   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93385   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93386   {
93387     try {
93388       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93389     } catch (std::out_of_range& e) {
93390       {
93391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93392       };
93393     } catch (std::exception& e) {
93394       {
93395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93396       };
93397     } catch (Dali::DaliException e) {
93398       {
93399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93400       };
93401     } catch (...) {
93402       {
93403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93404       };
93405     }
93406   }
93407
93408 }
93409
93410
93411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93412   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93413   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93414
93415   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93416   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93417   {
93418     try {
93419       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93420     } catch (std::out_of_range& e) {
93421       {
93422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93423       };
93424     } catch (std::exception& e) {
93425       {
93426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93427       };
93428     } catch (Dali::DaliException e) {
93429       {
93430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93431       };
93432     } catch (...) {
93433       {
93434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93435       };
93436     }
93437   }
93438
93439 }
93440
93441
93442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93443   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93444   Dali::Toolkit::VideoView *arg2 = 0 ;
93445
93446   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93447   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93448   if (!arg2) {
93449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93450     return ;
93451   }
93452   {
93453     try {
93454       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93455     } catch (std::out_of_range& e) {
93456       {
93457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93458       };
93459     } catch (std::exception& e) {
93460       {
93461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93462       };
93463     } catch (Dali::DaliException e) {
93464       {
93465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93466       };
93467     } catch (...) {
93468       {
93469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93470       };
93471     }
93472   }
93473
93474 }
93475
93476
93477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93478   void * jresult ;
93479   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93480
93481   {
93482     try {
93483       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93484     } catch (std::out_of_range& e) {
93485       {
93486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93487       };
93488     } catch (std::exception& e) {
93489       {
93490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93491       };
93492     } catch (Dali::DaliException e) {
93493       {
93494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93495       };
93496     } catch (...) {
93497       {
93498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93499       };
93500     }
93501   }
93502
93503   jresult = (void *)result;
93504   return jresult;
93505 }
93506
93507
93508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93509   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93510
93511   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93512   {
93513     try {
93514       delete arg1;
93515     } catch (std::out_of_range& e) {
93516       {
93517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93518       };
93519     } catch (std::exception& e) {
93520       {
93521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93522       };
93523     } catch (Dali::DaliException e) {
93524       {
93525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93526       };
93527     } catch (...) {
93528       {
93529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93530       };
93531     }
93532   }
93533
93534 }
93535
93536
93537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93538   unsigned int jresult ;
93539   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93540   bool result;
93541
93542   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93543   {
93544     try {
93545       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93546     } catch (std::out_of_range& e) {
93547       {
93548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93549       };
93550     } catch (std::exception& e) {
93551       {
93552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93553       };
93554     } catch (Dali::DaliException e) {
93555       {
93556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93557       };
93558     } catch (...) {
93559       {
93560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93561       };
93562     }
93563   }
93564
93565   jresult = result;
93566   return jresult;
93567 }
93568
93569
93570 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93571   unsigned long jresult ;
93572   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93573   std::size_t result;
93574
93575   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93576   {
93577     try {
93578       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93579     } catch (std::out_of_range& e) {
93580       {
93581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93582       };
93583     } catch (std::exception& e) {
93584       {
93585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93586       };
93587     } catch (Dali::DaliException e) {
93588       {
93589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93590       };
93591     } catch (...) {
93592       {
93593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93594       };
93595     }
93596   }
93597
93598   jresult = (unsigned long)result;
93599   return jresult;
93600 }
93601
93602
93603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93604   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93605   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93606
93607   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93608   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93609   {
93610     try {
93611       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93612     } catch (std::out_of_range& e) {
93613       {
93614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93615       };
93616     } catch (std::exception& e) {
93617       {
93618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93619       };
93620     } catch (Dali::DaliException e) {
93621       {
93622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93623       };
93624     } catch (...) {
93625       {
93626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93627       };
93628     }
93629   }
93630
93631 }
93632
93633
93634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93635   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93636   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93637
93638   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93639   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93640   {
93641     try {
93642       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93643     } catch (std::out_of_range& e) {
93644       {
93645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93646       };
93647     } catch (std::exception& e) {
93648       {
93649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93650       };
93651     } catch (Dali::DaliException e) {
93652       {
93653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93654       };
93655     } catch (...) {
93656       {
93657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93658       };
93659     }
93660   }
93661
93662 }
93663
93664
93665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93666   unsigned int jresult ;
93667   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93668   Dali::Toolkit::Slider arg2 ;
93669   float arg3 ;
93670   Dali::Toolkit::Slider *argp2 ;
93671   bool result;
93672
93673   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93674   argp2 = (Dali::Toolkit::Slider *)jarg2;
93675   if (!argp2) {
93676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93677     return 0;
93678   }
93679   arg2 = *argp2;
93680   arg3 = (float)jarg3;
93681   {
93682     try {
93683       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93684     } catch (std::out_of_range& e) {
93685       {
93686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93687       };
93688     } catch (std::exception& e) {
93689       {
93690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93691       };
93692     } catch (Dali::DaliException e) {
93693       {
93694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93695       };
93696     } catch (...) {
93697       {
93698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93699       };
93700     }
93701   }
93702
93703   jresult = result;
93704   return jresult;
93705 }
93706
93707
93708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93709   void * jresult ;
93710   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93711
93712   {
93713     try {
93714       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93715     } catch (std::out_of_range& e) {
93716       {
93717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93718       };
93719     } catch (std::exception& e) {
93720       {
93721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93722       };
93723     } catch (Dali::DaliException e) {
93724       {
93725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93726       };
93727     } catch (...) {
93728       {
93729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93730       };
93731     }
93732   }
93733
93734   jresult = (void *)result;
93735   return jresult;
93736 }
93737
93738
93739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93740   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93741
93742   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93743   {
93744     try {
93745       delete arg1;
93746     } catch (std::out_of_range& e) {
93747       {
93748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93749       };
93750     } catch (std::exception& e) {
93751       {
93752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93753       };
93754     } catch (Dali::DaliException e) {
93755       {
93756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93757       };
93758     } catch (...) {
93759       {
93760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93761       };
93762     }
93763   }
93764
93765 }
93766
93767
93768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93769   unsigned int jresult ;
93770   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93771   bool result;
93772
93773   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93774   {
93775     try {
93776       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93777     } catch (std::out_of_range& e) {
93778       {
93779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93780       };
93781     } catch (std::exception& e) {
93782       {
93783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93784       };
93785     } catch (Dali::DaliException e) {
93786       {
93787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93788       };
93789     } catch (...) {
93790       {
93791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93792       };
93793     }
93794   }
93795
93796   jresult = result;
93797   return jresult;
93798 }
93799
93800
93801 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93802   unsigned long jresult ;
93803   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93804   std::size_t result;
93805
93806   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93807   {
93808     try {
93809       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93810     } catch (std::out_of_range& e) {
93811       {
93812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93813       };
93814     } catch (std::exception& e) {
93815       {
93816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93817       };
93818     } catch (Dali::DaliException e) {
93819       {
93820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93821       };
93822     } catch (...) {
93823       {
93824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93825       };
93826     }
93827   }
93828
93829   jresult = (unsigned long)result;
93830   return jresult;
93831 }
93832
93833
93834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
93835   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93836   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93837
93838   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93839   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93840   {
93841     try {
93842       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
93843     } catch (std::out_of_range& e) {
93844       {
93845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93846       };
93847     } catch (std::exception& e) {
93848       {
93849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93850       };
93851     } catch (Dali::DaliException e) {
93852       {
93853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93854       };
93855     } catch (...) {
93856       {
93857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93858       };
93859     }
93860   }
93861
93862 }
93863
93864
93865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
93866   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93867   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93868
93869   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93870   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93871   {
93872     try {
93873       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
93874     } catch (std::out_of_range& e) {
93875       {
93876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93877       };
93878     } catch (std::exception& e) {
93879       {
93880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93881       };
93882     } catch (Dali::DaliException e) {
93883       {
93884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93885       };
93886     } catch (...) {
93887       {
93888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93889       };
93890     }
93891   }
93892
93893 }
93894
93895
93896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93897   unsigned int jresult ;
93898   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93899   Dali::Toolkit::Slider arg2 ;
93900   int arg3 ;
93901   Dali::Toolkit::Slider *argp2 ;
93902   bool result;
93903
93904   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93905   argp2 = (Dali::Toolkit::Slider *)jarg2;
93906   if (!argp2) {
93907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93908     return 0;
93909   }
93910   arg2 = *argp2;
93911   arg3 = (int)jarg3;
93912   {
93913     try {
93914       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
93915     } catch (std::out_of_range& e) {
93916       {
93917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93918       };
93919     } catch (std::exception& e) {
93920       {
93921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93922       };
93923     } catch (Dali::DaliException e) {
93924       {
93925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93926       };
93927     } catch (...) {
93928       {
93929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93930       };
93931     }
93932   }
93933
93934   jresult = result;
93935   return jresult;
93936 }
93937
93938
93939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
93940   void * jresult ;
93941   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
93942
93943   {
93944     try {
93945       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
93946     } catch (std::out_of_range& e) {
93947       {
93948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93949       };
93950     } catch (std::exception& e) {
93951       {
93952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93953       };
93954     } catch (Dali::DaliException e) {
93955       {
93956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93957       };
93958     } catch (...) {
93959       {
93960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93961       };
93962     }
93963   }
93964
93965   jresult = (void *)result;
93966   return jresult;
93967 }
93968
93969
93970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
93971   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93972
93973   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93974   {
93975     try {
93976       delete arg1;
93977     } catch (std::out_of_range& e) {
93978       {
93979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93980       };
93981     } catch (std::exception& e) {
93982       {
93983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93984       };
93985     } catch (Dali::DaliException e) {
93986       {
93987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93988       };
93989     } catch (...) {
93990       {
93991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93992       };
93993     }
93994   }
93995
93996 }
93997
93998
93999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
94000   void * jresult ;
94001   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94002
94003   {
94004     try {
94005       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
94006     } catch (std::out_of_range& e) {
94007       {
94008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94009       };
94010     } catch (std::exception& e) {
94011       {
94012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94013       };
94014     } catch (Dali::DaliException e) {
94015       {
94016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94017       };
94018     } catch (...) {
94019       {
94020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94021       };
94022     }
94023   }
94024
94025   jresult = (void *)result;
94026   return jresult;
94027 }
94028
94029
94030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
94031   void * jresult ;
94032   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
94033   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94034
94035   arg1 = (Dali::Toolkit::Ruler *)jarg1;
94036   {
94037     try {
94038       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
94039     } catch (std::out_of_range& e) {
94040       {
94041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94042       };
94043     } catch (std::exception& e) {
94044       {
94045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94046       };
94047     } catch (Dali::DaliException e) {
94048       {
94049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94050       };
94051     } catch (...) {
94052       {
94053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94054       };
94055     }
94056   }
94057
94058   jresult = (void *)result;
94059   return jresult;
94060 }
94061
94062
94063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
94064   void * jresult ;
94065   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
94066   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94067
94068   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94069   if (!arg1) {
94070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94071     return 0;
94072   }
94073   {
94074     try {
94075       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
94076     } catch (std::out_of_range& e) {
94077       {
94078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94079       };
94080     } catch (std::exception& e) {
94081       {
94082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94083       };
94084     } catch (Dali::DaliException e) {
94085       {
94086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94087       };
94088     } catch (...) {
94089       {
94090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94091       };
94092     }
94093   }
94094
94095   jresult = (void *)result;
94096   return jresult;
94097 }
94098
94099
94100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
94101   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94102
94103   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94104   {
94105     try {
94106       delete arg1;
94107     } catch (std::out_of_range& e) {
94108       {
94109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94110       };
94111     } catch (std::exception& e) {
94112       {
94113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94114       };
94115     } catch (Dali::DaliException e) {
94116       {
94117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94118       };
94119     } catch (...) {
94120       {
94121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94122       };
94123     }
94124   }
94125
94126 }
94127
94128
94129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
94130   void * jresult ;
94131   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94132   Dali::Toolkit::Ruler *result = 0 ;
94133
94134   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94135   {
94136     try {
94137       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
94138     } catch (std::out_of_range& e) {
94139       {
94140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94141       };
94142     } catch (std::exception& e) {
94143       {
94144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94145       };
94146     } catch (Dali::DaliException e) {
94147       {
94148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94149       };
94150     } catch (...) {
94151       {
94152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94153       };
94154     }
94155   }
94156
94157   jresult = (void *)result;
94158   return jresult;
94159 }
94160
94161
94162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
94163   void * jresult ;
94164   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94165   Dali::Toolkit::Ruler *result = 0 ;
94166
94167   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94168   {
94169     try {
94170       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
94171     } catch (std::out_of_range& e) {
94172       {
94173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94174       };
94175     } catch (std::exception& e) {
94176       {
94177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94178       };
94179     } catch (Dali::DaliException e) {
94180       {
94181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94182       };
94183     } catch (...) {
94184       {
94185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94186       };
94187     }
94188   }
94189
94190   jresult = (void *)result;
94191   return jresult;
94192 }
94193
94194
94195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94196   void * jresult ;
94197   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94198   Dali::Toolkit::Ruler *result = 0 ;
94199
94200   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94201   {
94202     try {
94203       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94204     } catch (std::out_of_range& e) {
94205       {
94206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94207       };
94208     } catch (std::exception& e) {
94209       {
94210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94211       };
94212     } catch (Dali::DaliException e) {
94213       {
94214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94215       };
94216     } catch (...) {
94217       {
94218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94219       };
94220     }
94221   }
94222
94223   jresult = (void *)result;
94224   return jresult;
94225 }
94226
94227
94228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94229   void * jresult ;
94230   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94231   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94232   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94233
94234   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94235   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94236   if (!arg2) {
94237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94238     return 0;
94239   }
94240   {
94241     try {
94242       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94243     } catch (std::out_of_range& e) {
94244       {
94245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94246       };
94247     } catch (std::exception& e) {
94248       {
94249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94250       };
94251     } catch (Dali::DaliException e) {
94252       {
94253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94254       };
94255     } catch (...) {
94256       {
94257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94258       };
94259     }
94260   }
94261
94262   jresult = (void *)result;
94263   return jresult;
94264 }
94265
94266
94267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94268   void * jresult ;
94269   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94270   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94271   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94272
94273   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94274   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94275   {
94276     try {
94277       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94278     } catch (std::out_of_range& e) {
94279       {
94280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94281       };
94282     } catch (std::exception& e) {
94283       {
94284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94285       };
94286     } catch (Dali::DaliException e) {
94287       {
94288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94289       };
94290     } catch (...) {
94291       {
94292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94293       };
94294     }
94295   }
94296
94297   jresult = (void *)result;
94298   return jresult;
94299 }
94300
94301
94302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94303   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94304
94305   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94306   {
94307     try {
94308       (arg1)->Reset();
94309     } catch (std::out_of_range& e) {
94310       {
94311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94312       };
94313     } catch (std::exception& e) {
94314       {
94315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94316       };
94317     } catch (Dali::DaliException e) {
94318       {
94319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94320       };
94321     } catch (...) {
94322       {
94323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94324       };
94325     }
94326   }
94327
94328 }
94329
94330
94331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94332   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94333   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94334
94335   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94336   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94337   {
94338     try {
94339       (arg1)->Reset(arg2);
94340     } catch (std::out_of_range& e) {
94341       {
94342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94343       };
94344     } catch (std::exception& e) {
94345       {
94346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94347       };
94348     } catch (Dali::DaliException e) {
94349       {
94350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94351       };
94352     } catch (...) {
94353       {
94354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94355       };
94356     }
94357   }
94358
94359 }
94360
94361
94362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94363   void * jresult ;
94364   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94365   Dali::Toolkit::Ruler *result = 0 ;
94366
94367   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94368   {
94369     try {
94370       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94371     } catch (std::out_of_range& e) {
94372       {
94373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94374       };
94375     } catch (std::exception& e) {
94376       {
94377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94378       };
94379     } catch (Dali::DaliException e) {
94380       {
94381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94382       };
94383     } catch (...) {
94384       {
94385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94386       };
94387     }
94388   }
94389
94390   jresult = (void *)result;
94391   return jresult;
94392 }
94393
94394
94395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94396   float jresult ;
94397   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94398   float arg2 ;
94399   float arg3 ;
94400   float result;
94401
94402   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94403   arg2 = (float)jarg2;
94404   arg3 = (float)jarg3;
94405   {
94406     try {
94407       result = (float)(*arg1)->Snap(arg2,arg3);
94408     } catch (std::out_of_range& e) {
94409       {
94410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94411       };
94412     } catch (std::exception& e) {
94413       {
94414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94415       };
94416     } catch (Dali::DaliException e) {
94417       {
94418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94419       };
94420     } catch (...) {
94421       {
94422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94423       };
94424     }
94425   }
94426
94427   jresult = result;
94428   return jresult;
94429 }
94430
94431
94432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94433   float jresult ;
94434   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94435   float arg2 ;
94436   float result;
94437
94438   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94439   arg2 = (float)jarg2;
94440   {
94441     try {
94442       result = (float)(*arg1)->Snap(arg2);
94443     } catch (std::out_of_range& e) {
94444       {
94445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94446       };
94447     } catch (std::exception& e) {
94448       {
94449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94450       };
94451     } catch (Dali::DaliException e) {
94452       {
94453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94454       };
94455     } catch (...) {
94456       {
94457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94458       };
94459     }
94460   }
94461
94462   jresult = result;
94463   return jresult;
94464 }
94465
94466
94467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94468   float jresult ;
94469   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94470   unsigned int arg2 ;
94471   unsigned int *arg3 = 0 ;
94472   bool arg4 ;
94473   float result;
94474
94475   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94476   arg2 = (unsigned int)jarg2;
94477   arg3 = (unsigned int *)jarg3;
94478   arg4 = jarg4 ? true : false;
94479   {
94480     try {
94481       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94482     } catch (std::out_of_range& e) {
94483       {
94484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94485       };
94486     } catch (std::exception& e) {
94487       {
94488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94489       };
94490     } catch (Dali::DaliException e) {
94491       {
94492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94493       };
94494     } catch (...) {
94495       {
94496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94497       };
94498     }
94499   }
94500
94501   jresult = result;
94502   return jresult;
94503 }
94504
94505
94506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94507   unsigned int jresult ;
94508   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94509   float arg2 ;
94510   bool arg3 ;
94511   unsigned int result;
94512
94513   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94514   arg2 = (float)jarg2;
94515   arg3 = jarg3 ? true : false;
94516   {
94517     try {
94518       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94519     } catch (std::out_of_range& e) {
94520       {
94521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94522       };
94523     } catch (std::exception& e) {
94524       {
94525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94526       };
94527     } catch (Dali::DaliException e) {
94528       {
94529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94530       };
94531     } catch (...) {
94532       {
94533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94534       };
94535     }
94536   }
94537
94538   jresult = result;
94539   return jresult;
94540 }
94541
94542
94543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94544   unsigned int jresult ;
94545   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94546   unsigned int result;
94547
94548   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94549   {
94550     try {
94551       result = (unsigned int)(*arg1)->GetTotalPages();
94552     } catch (std::out_of_range& e) {
94553       {
94554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94555       };
94556     } catch (std::exception& e) {
94557       {
94558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94559       };
94560     } catch (Dali::DaliException e) {
94561       {
94562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94563       };
94564     } catch (...) {
94565       {
94566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94567       };
94568     }
94569   }
94570
94571   jresult = result;
94572   return jresult;
94573 }
94574
94575
94576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94577   int jresult ;
94578   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94579   Dali::Toolkit::Ruler::RulerType result;
94580
94581   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94582   {
94583     try {
94584       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94585     } catch (std::out_of_range& e) {
94586       {
94587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94588       };
94589     } catch (std::exception& e) {
94590       {
94591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94592       };
94593     } catch (Dali::DaliException e) {
94594       {
94595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94596       };
94597     } catch (...) {
94598       {
94599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94600       };
94601     }
94602   }
94603
94604   jresult = (int)result;
94605   return jresult;
94606 }
94607
94608
94609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94610   unsigned int jresult ;
94611   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94612   bool result;
94613
94614   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94615   {
94616     try {
94617       result = (bool)(*arg1)->IsEnabled();
94618     } catch (std::out_of_range& e) {
94619       {
94620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94621       };
94622     } catch (std::exception& e) {
94623       {
94624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94625       };
94626     } catch (Dali::DaliException e) {
94627       {
94628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94629       };
94630     } catch (...) {
94631       {
94632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94633       };
94634     }
94635   }
94636
94637   jresult = result;
94638   return jresult;
94639 }
94640
94641
94642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94643   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94644
94645   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94646   {
94647     try {
94648       (*arg1)->Enable();
94649     } catch (std::out_of_range& e) {
94650       {
94651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94652       };
94653     } catch (std::exception& e) {
94654       {
94655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94656       };
94657     } catch (Dali::DaliException e) {
94658       {
94659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94660       };
94661     } catch (...) {
94662       {
94663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94664       };
94665     }
94666   }
94667
94668 }
94669
94670
94671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94672   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94673
94674   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94675   {
94676     try {
94677       (*arg1)->Disable();
94678     } catch (std::out_of_range& e) {
94679       {
94680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94681       };
94682     } catch (std::exception& e) {
94683       {
94684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94685       };
94686     } catch (Dali::DaliException e) {
94687       {
94688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94689       };
94690     } catch (...) {
94691       {
94692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94693       };
94694     }
94695   }
94696
94697 }
94698
94699
94700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94701   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94702   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94703   Dali::Toolkit::RulerDomain *argp2 ;
94704
94705   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94706   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94707   if (!argp2) {
94708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94709     return ;
94710   }
94711   arg2 = *argp2;
94712   {
94713     try {
94714       (*arg1)->SetDomain(arg2);
94715     } catch (std::out_of_range& e) {
94716       {
94717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94718       };
94719     } catch (std::exception& e) {
94720       {
94721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94722       };
94723     } catch (Dali::DaliException e) {
94724       {
94725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94726       };
94727     } catch (...) {
94728       {
94729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94730       };
94731     }
94732   }
94733
94734 }
94735
94736
94737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94738   void * jresult ;
94739   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94740   Dali::Toolkit::RulerDomain *result = 0 ;
94741
94742   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94743   {
94744     try {
94745       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94746     } catch (std::out_of_range& e) {
94747       {
94748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94749       };
94750     } catch (std::exception& e) {
94751       {
94752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94753       };
94754     } catch (Dali::DaliException e) {
94755       {
94756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94757       };
94758     } catch (...) {
94759       {
94760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94761       };
94762     }
94763   }
94764
94765   jresult = (void *)result;
94766   return jresult;
94767 }
94768
94769
94770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94771   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94772
94773   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94774   {
94775     try {
94776       (*arg1)->DisableDomain();
94777     } catch (std::out_of_range& e) {
94778       {
94779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94780       };
94781     } catch (std::exception& e) {
94782       {
94783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94784       };
94785     } catch (Dali::DaliException e) {
94786       {
94787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94788       };
94789     } catch (...) {
94790       {
94791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94792       };
94793     }
94794   }
94795
94796 }
94797
94798
94799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94800   float jresult ;
94801   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94802   float arg2 ;
94803   float arg3 ;
94804   float arg4 ;
94805   float result;
94806
94807   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94808   arg2 = (float)jarg2;
94809   arg3 = (float)jarg3;
94810   arg4 = (float)jarg4;
94811   {
94812     try {
94813       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94814     } catch (std::out_of_range& e) {
94815       {
94816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94817       };
94818     } catch (std::exception& e) {
94819       {
94820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94821       };
94822     } catch (Dali::DaliException e) {
94823       {
94824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94825       };
94826     } catch (...) {
94827       {
94828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94829       };
94830     }
94831   }
94832
94833   jresult = result;
94834   return jresult;
94835 }
94836
94837
94838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
94839   float jresult ;
94840   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94841   float arg2 ;
94842   float arg3 ;
94843   float result;
94844
94845   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94846   arg2 = (float)jarg2;
94847   arg3 = (float)jarg3;
94848   {
94849     try {
94850       result = (float)(*arg1)->Clamp(arg2,arg3);
94851     } catch (std::out_of_range& e) {
94852       {
94853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94854       };
94855     } catch (std::exception& e) {
94856       {
94857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94858       };
94859     } catch (Dali::DaliException e) {
94860       {
94861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94862       };
94863     } catch (...) {
94864       {
94865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94866       };
94867     }
94868   }
94869
94870   jresult = result;
94871   return jresult;
94872 }
94873
94874
94875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
94876   float jresult ;
94877   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94878   float arg2 ;
94879   float result;
94880
94881   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94882   arg2 = (float)jarg2;
94883   {
94884     try {
94885       result = (float)(*arg1)->Clamp(arg2);
94886     } catch (std::out_of_range& e) {
94887       {
94888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94889       };
94890     } catch (std::exception& e) {
94891       {
94892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94893       };
94894     } catch (Dali::DaliException e) {
94895       {
94896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94897       };
94898     } catch (...) {
94899       {
94900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94901       };
94902     }
94903   }
94904
94905   jresult = result;
94906   return jresult;
94907 }
94908
94909
94910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
94911   float jresult ;
94912   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94913   float arg2 ;
94914   float arg3 ;
94915   float arg4 ;
94916   Dali::Toolkit::ClampState *arg5 = 0 ;
94917   float result;
94918
94919   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94920   arg2 = (float)jarg2;
94921   arg3 = (float)jarg3;
94922   arg4 = (float)jarg4;
94923   arg5 = (Dali::Toolkit::ClampState *)jarg5;
94924   if (!arg5) {
94925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94926     return 0;
94927   }
94928   {
94929     try {
94930       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
94931     } catch (std::out_of_range& e) {
94932       {
94933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94934       };
94935     } catch (std::exception& e) {
94936       {
94937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94938       };
94939     } catch (Dali::DaliException e) {
94940       {
94941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94942       };
94943     } catch (...) {
94944       {
94945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94946       };
94947     }
94948   }
94949
94950   jresult = result;
94951   return jresult;
94952 }
94953
94954
94955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
94956   float jresult ;
94957   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94958   float arg2 ;
94959   float arg3 ;
94960   float arg4 ;
94961   float arg5 ;
94962   float result;
94963
94964   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94965   arg2 = (float)jarg2;
94966   arg3 = (float)jarg3;
94967   arg4 = (float)jarg4;
94968   arg5 = (float)jarg5;
94969   {
94970     try {
94971       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
94972     } catch (std::out_of_range& e) {
94973       {
94974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94975       };
94976     } catch (std::exception& e) {
94977       {
94978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94979       };
94980     } catch (Dali::DaliException e) {
94981       {
94982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94983       };
94984     } catch (...) {
94985       {
94986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94987       };
94988     }
94989   }
94990
94991   jresult = result;
94992   return jresult;
94993 }
94994
94995
94996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
94997   float jresult ;
94998   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94999   float arg2 ;
95000   float arg3 ;
95001   float arg4 ;
95002   float result;
95003
95004   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95005   arg2 = (float)jarg2;
95006   arg3 = (float)jarg3;
95007   arg4 = (float)jarg4;
95008   {
95009     try {
95010       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
95011     } catch (std::out_of_range& e) {
95012       {
95013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95014       };
95015     } catch (std::exception& e) {
95016       {
95017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95018       };
95019     } catch (Dali::DaliException e) {
95020       {
95021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95022       };
95023     } catch (...) {
95024       {
95025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95026       };
95027     }
95028   }
95029
95030   jresult = result;
95031   return jresult;
95032 }
95033
95034
95035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
95036   float jresult ;
95037   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95038   float arg2 ;
95039   float arg3 ;
95040   float result;
95041
95042   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95043   arg2 = (float)jarg2;
95044   arg3 = (float)jarg3;
95045   {
95046     try {
95047       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
95048     } catch (std::out_of_range& e) {
95049       {
95050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95051       };
95052     } catch (std::exception& e) {
95053       {
95054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95055       };
95056     } catch (Dali::DaliException e) {
95057       {
95058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95059       };
95060     } catch (...) {
95061       {
95062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95063       };
95064     }
95065   }
95066
95067   jresult = result;
95068   return jresult;
95069 }
95070
95071
95072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
95073   float jresult ;
95074   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95075   float arg2 ;
95076   float result;
95077
95078   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95079   arg2 = (float)jarg2;
95080   {
95081     try {
95082       result = (float)(*arg1)->SnapAndClamp(arg2);
95083     } catch (std::out_of_range& e) {
95084       {
95085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95086       };
95087     } catch (std::exception& e) {
95088       {
95089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95090       };
95091     } catch (Dali::DaliException e) {
95092       {
95093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95094       };
95095     } catch (...) {
95096       {
95097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95098       };
95099     }
95100   }
95101
95102   jresult = result;
95103   return jresult;
95104 }
95105
95106
95107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
95108   float jresult ;
95109   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95110   float arg2 ;
95111   float arg3 ;
95112   float arg4 ;
95113   float arg5 ;
95114   Dali::Toolkit::ClampState *arg6 = 0 ;
95115   float result;
95116
95117   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95118   arg2 = (float)jarg2;
95119   arg3 = (float)jarg3;
95120   arg4 = (float)jarg4;
95121   arg5 = (float)jarg5;
95122   arg6 = (Dali::Toolkit::ClampState *)jarg6;
95123   if (!arg6) {
95124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95125     return 0;
95126   }
95127   {
95128     try {
95129       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
95130     } catch (std::out_of_range& e) {
95131       {
95132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95133       };
95134     } catch (std::exception& e) {
95135       {
95136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95137       };
95138     } catch (Dali::DaliException e) {
95139       {
95140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95141       };
95142     } catch (...) {
95143       {
95144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95145       };
95146     }
95147   }
95148
95149   jresult = result;
95150   return jresult;
95151 }
95152
95153
95154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
95155   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95156
95157   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95158   {
95159     try {
95160       (*arg1)->Reference();
95161     } catch (std::out_of_range& e) {
95162       {
95163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95164       };
95165     } catch (std::exception& e) {
95166       {
95167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95168       };
95169     } catch (Dali::DaliException e) {
95170       {
95171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95172       };
95173     } catch (...) {
95174       {
95175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95176       };
95177     }
95178   }
95179
95180 }
95181
95182
95183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95184   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95185
95186   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95187   {
95188     try {
95189       (*arg1)->Unreference();
95190     } catch (std::out_of_range& e) {
95191       {
95192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95193       };
95194     } catch (std::exception& e) {
95195       {
95196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95197       };
95198     } catch (Dali::DaliException e) {
95199       {
95200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95201       };
95202     } catch (...) {
95203       {
95204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95205       };
95206     }
95207   }
95208
95209 }
95210
95211
95212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95213   int jresult ;
95214   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95215   int result;
95216
95217   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95218   {
95219     try {
95220       result = (int)(*arg1)->ReferenceCount();
95221     } catch (std::out_of_range& e) {
95222       {
95223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95224       };
95225     } catch (std::exception& e) {
95226       {
95227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95228       };
95229     } catch (Dali::DaliException e) {
95230       {
95231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95232       };
95233     } catch (...) {
95234       {
95235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95236       };
95237     }
95238   }
95239
95240   jresult = result;
95241   return jresult;
95242 }
95243
95244
95245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95246   unsigned int jresult ;
95247   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95248   bool result;
95249
95250   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95251   {
95252     try {
95253       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95254     } catch (std::out_of_range& e) {
95255       {
95256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95257       };
95258     } catch (std::exception& e) {
95259       {
95260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95261       };
95262     } catch (Dali::DaliException e) {
95263       {
95264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95265       };
95266     } catch (...) {
95267       {
95268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95269       };
95270     }
95271   }
95272
95273   jresult = result;
95274   return jresult;
95275 }
95276
95277
95278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95279   unsigned long jresult ;
95280   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95281   std::size_t result;
95282
95283   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95284   {
95285     try {
95286       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95287     } catch (std::out_of_range& e) {
95288       {
95289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95290       };
95291     } catch (std::exception& e) {
95292       {
95293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95294       };
95295     } catch (Dali::DaliException e) {
95296       {
95297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95298       };
95299     } catch (...) {
95300       {
95301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95302       };
95303     }
95304   }
95305
95306   jresult = (unsigned long)result;
95307   return jresult;
95308 }
95309
95310
95311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95312   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95313   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95314
95315   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95316   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95317   {
95318     try {
95319       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95320     } catch (std::out_of_range& e) {
95321       {
95322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95323       };
95324     } catch (std::exception& e) {
95325       {
95326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95327       };
95328     } catch (Dali::DaliException e) {
95329       {
95330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95331       };
95332     } catch (...) {
95333       {
95334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95335       };
95336     }
95337   }
95338
95339 }
95340
95341
95342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95343   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95344   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95345
95346   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95347   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95348   {
95349     try {
95350       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95351     } catch (std::out_of_range& e) {
95352       {
95353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95354       };
95355     } catch (std::exception& e) {
95356       {
95357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95358       };
95359     } catch (Dali::DaliException e) {
95360       {
95361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95362       };
95363     } catch (...) {
95364       {
95365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95366       };
95367     }
95368   }
95369
95370 }
95371
95372
95373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95374   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95375   Dali::Toolkit::Control arg2 ;
95376   Dali::Toolkit::Control *argp2 ;
95377
95378   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95379   argp2 = (Dali::Toolkit::Control *)jarg2;
95380   if (!argp2) {
95381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95382     return ;
95383   }
95384   arg2 = *argp2;
95385   {
95386     try {
95387       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95388     } catch (std::out_of_range& e) {
95389       {
95390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95391       };
95392     } catch (std::exception& e) {
95393       {
95394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95395       };
95396     } catch (Dali::DaliException e) {
95397       {
95398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95399       };
95400     } catch (...) {
95401       {
95402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95403       };
95404     }
95405   }
95406
95407 }
95408
95409
95410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95411   void * jresult ;
95412   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95413
95414   {
95415     try {
95416       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95417     } catch (std::out_of_range& e) {
95418       {
95419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95420       };
95421     } catch (std::exception& e) {
95422       {
95423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95424       };
95425     } catch (Dali::DaliException e) {
95426       {
95427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95428       };
95429     } catch (...) {
95430       {
95431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95432       };
95433     }
95434   }
95435
95436   jresult = (void *)result;
95437   return jresult;
95438 }
95439
95440
95441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95442   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95443
95444   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95445   {
95446     try {
95447       delete arg1;
95448     } catch (std::out_of_range& e) {
95449       {
95450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95451       };
95452     } catch (std::exception& e) {
95453       {
95454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95455       };
95456     } catch (Dali::DaliException e) {
95457       {
95458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95459       };
95460     } catch (...) {
95461       {
95462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95463       };
95464     }
95465   }
95466
95467 }
95468
95469 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95470   Dali::RefObject *result = NULL;
95471
95472   if (arg1)
95473   {
95474     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95475   }
95476   return result;
95477 }
95478
95479 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95480     return (Dali::RefObject *)jarg1;
95481 }
95482
95483 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95484     return (Dali::SignalObserver *)jarg1;
95485 }
95486
95487 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95488     return (Dali::ConnectionTrackerInterface *)jarg1;
95489 }
95490
95491 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95492     return (Dali::BaseHandle *)jarg1;
95493 }
95494
95495 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95496     return (Dali::BaseHandle *)jarg1;
95497 }
95498
95499 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95500     return (Dali::BaseHandle *)jarg1;
95501 }
95502
95503 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95504     return (Dali::BaseHandle *)jarg1;
95505 }
95506
95507 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95508     return (Dali::BaseHandle *)jarg1;
95509 }
95510
95511 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95512     return (Dali::BaseHandle *)jarg1;
95513 }
95514
95515 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95516     return (Dali::BaseHandle *)jarg1;
95517 }
95518
95519 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95520     return (Dali::BaseHandle *)jarg1;
95521 }
95522
95523 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95524     return (Dali::BaseHandle *)jarg1;
95525 }
95526
95527 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95528     return (Dali::BaseHandle *)jarg1;
95529 }
95530
95531 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
95532     return (Dali::BaseHandle *)jarg1;
95533 }
95534
95535 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95536     return (Dali::BaseHandle *)jarg1;
95537 }
95538
95539 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95540     return (Dali::Handle *)jarg1;
95541 }
95542
95543 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95544     return (Dali::Handle *)jarg1;
95545 }
95546
95547 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95548     return (Dali::BaseHandle *)jarg1;
95549 }
95550
95551 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95552     return (Dali::BaseHandle *)jarg1;
95553 }
95554
95555 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95556     return (Dali::Handle *)jarg1;
95557 }
95558
95559 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
95560     return (Dali::BaseHandle *)jarg1;
95561 }
95562
95563 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
95564     return (Dali::BaseHandle *)jarg1;
95565 }
95566
95567 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
95568     return (Dali::BaseHandle *)jarg1;
95569 }
95570
95571 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95572     return (Dali::Handle *)jarg1;
95573 }
95574
95575 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95576     return (Dali::GestureDetector *)jarg1;
95577 }
95578
95579 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95580     return (Dali::Gesture *)jarg1;
95581 }
95582
95583 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95584     return (Dali::Handle *)jarg1;
95585 }
95586
95587 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95588     return (Dali::Actor *)jarg1;
95589 }
95590
95591 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95592     return (Dali::RefObject *)jarg1;
95593 }
95594
95595 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95596     return (Dali::Actor *)jarg1;
95597 }
95598
95599 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95600     return (Dali::GestureDetector *)jarg1;
95601 }
95602
95603 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95604     return (Dali::Gesture *)jarg1;
95605 }
95606
95607 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95608     return (Dali::GestureDetector *)jarg1;
95609 }
95610
95611 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95612     return (Dali::Gesture *)jarg1;
95613 }
95614
95615 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95616     return (Dali::GestureDetector *)jarg1;
95617 }
95618
95619 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95620     return (Dali::Gesture *)jarg1;
95621 }
95622
95623 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95624     return (Dali::BaseHandle *)jarg1;
95625 }
95626
95627 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95628     return (Dali::Handle *)jarg1;
95629 }
95630
95631 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95632     return (Dali::Handle *)jarg1;
95633 }
95634
95635 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95636     return (Dali::Handle *)jarg1;
95637 }
95638
95639 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95640     return (Dali::RefObject *)jarg1;
95641 }
95642
95643 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95644     return (Dali::Actor *)jarg1;
95645 }
95646
95647 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95648     return (Dali::BaseHandle *)jarg1;
95649 }
95650
95651 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95652     return (Dali::BaseHandle *)jarg1;
95653 }
95654
95655 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95656     return (Dali::BaseHandle *)jarg1;
95657 }
95658
95659 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95660     return (Dali::CustomActorImpl *)jarg1;
95661 }
95662
95663 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95664     return (Dali::CustomActor *)jarg1;
95665 }
95666
95667 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95668     return (Dali::BaseHandle *)jarg1;
95669 }
95670
95671 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95672     return (Dali::Toolkit::Control *)jarg1;
95673 }
95674
95675 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95676     return (Dali::Toolkit::Control *)jarg1;
95677 }
95678
95679 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95680     return (Dali::Toolkit::Button *)jarg1;
95681 }
95682
95683 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95684     return (Dali::Toolkit::Button *)jarg1;
95685 }
95686
95687 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95688     return (Dali::Toolkit::Button *)jarg1;
95689 }
95690
95691 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95692     return (Dali::Toolkit::Control *)jarg1;
95693 }
95694
95695 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95696     return (Dali::Toolkit::Control *)jarg1;
95697 }
95698
95699 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95700     return (Dali::Toolkit::Control *)jarg1;
95701 }
95702
95703 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95704     return (Dali::Toolkit::Control *)jarg1;
95705 }
95706
95707 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95708     return (Dali::Toolkit::Control *)jarg1;
95709 }
95710
95711 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95712     return (Dali::RefObject *)jarg1;
95713 }
95714
95715 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95716     return (Dali::Toolkit::Scrollable *)jarg1;
95717 }
95718
95719 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95720     return (Dali::BaseHandle *)jarg1;
95721 }
95722
95723 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95724     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95725 }
95726
95727 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95728     return (Dali::RefObject *)jarg1;
95729 }
95730
95731 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95732     return (Dali::Toolkit::Ruler *)jarg1;
95733 }
95734
95735 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95736     return (Dali::Toolkit::Ruler *)jarg1;
95737 }
95738
95739 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95740     return (Dali::Toolkit::Scrollable *)jarg1;
95741 }
95742
95743 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95744     return (Dali::Toolkit::Control *)jarg1;
95745 }
95746
95747
95748 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95749     return (Dali::Toolkit::Control *)jarg1;
95750 }
95751
95752 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95753     return (Dali::BaseHandle *)jarg1;
95754 }
95755
95756 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95757     return (Dali::BaseHandle *)jarg1;
95758 }
95759
95760 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95761     return (Dali::Toolkit::Control *)jarg1;
95762 }
95763
95764 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95765     return (Dali::Toolkit::Control *)jarg1;
95766 }
95767
95768 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95769     return (Dali::Toolkit::Control *)jarg1;
95770 }
95771
95772 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95773     return (Dali::Toolkit::Control *)jarg1;
95774 }
95775
95776 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95777     return (Dali::Toolkit::Control *)jarg1;
95778 }
95779
95780 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95781     return (Dali::Toolkit::Control *)jarg1;
95782 }
95783
95784 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95785     return (Dali::Toolkit::PageTurnView *)jarg1;
95786 }
95787
95788 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95789     return (Dali::Toolkit::PageTurnView *)jarg1;
95790 }
95791
95792 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95793     return (Dali::Toolkit::Button *)jarg1;
95794 }
95795
95796 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95797     return (Dali::BaseHandle *)jarg1;
95798 }
95799
95800 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95801     return (Dali::BaseHandle *)jarg1;
95802 }
95803
95804 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95805     return (Dali::BaseHandle *)jarg1;
95806 }
95807
95808 /*
95809  * Widget binding
95810  */
95811 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95812     return (Dali::BaseHandle *)jarg1;
95813 }
95814
95815 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95816     return (Dali::BaseObject *)jarg1;
95817 }
95818
95819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
95820   void * jresult ;
95821   Dali::Widget result;
95822
95823   {
95824     try {
95825       result = Dali::Widget::New();
95826     } catch (std::out_of_range& e) {
95827       {
95828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95829       };
95830     } catch (std::exception& e) {
95831       {
95832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95833       };
95834     } catch (...) {
95835       {
95836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95837       };
95838     }
95839   }
95840   jresult = new Dali::Widget((const Dali::Widget &)result);
95841   return jresult;
95842 }
95843
95844
95845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
95846   void * jresult ;
95847   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
95848   Dali::Widget result;
95849
95850   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95851
95852   if (!arg1) {
95853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
95854     return 0;
95855   }
95856   {
95857     try {
95858       jresult = new Dali::Widget(arg1);
95859     } catch (std::out_of_range& e) {
95860       {
95861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95862       };
95863     } catch (std::exception& e) {
95864       {
95865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95866       };
95867     } catch (...) {
95868       {
95869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95870       };
95871     }
95872   }
95873   return jresult;
95874 }
95875
95876
95877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
95878   void * jresult ;
95879   Dali::Widget *result = 0 ;
95880
95881   {
95882     try {
95883       result = (Dali::Widget *)new Dali::Widget();
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_Widget_Assign(void * jarg1, void * jarg2) {
95904   void * jresult ;
95905   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95906   Dali::Widget *arg2 = 0 ;
95907   Dali::Widget *result = 0 ;
95908
95909   arg1 = (Dali::Widget *)jarg1;
95910   arg2 = (Dali::Widget *)jarg2;
95911   if (!arg2) {
95912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
95913     return 0;
95914   }
95915   {
95916     try {
95917       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
95918     } catch (std::out_of_range& e) {
95919       {
95920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95921       };
95922     } catch (std::exception& e) {
95923       {
95924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95925       };
95926     } catch (...) {
95927       {
95928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95929       };
95930     }
95931   }
95932   jresult = (void *)result;
95933   return jresult;
95934 }
95935
95936
95937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
95938   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95939
95940   arg1 = (Dali::Widget *)jarg1;
95941   {
95942     try {
95943       delete arg1;
95944     } catch (std::out_of_range& e) {
95945       {
95946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95947       };
95948     } catch (std::exception& e) {
95949       {
95950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95951       };
95952     } catch (...) {
95953       {
95954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95955       };
95956     }
95957   }
95958 }
95959
95960
95961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
95962   void * jresult ;
95963   SwigDirector_WidgetImpl* result;
95964   {
95965     try {
95966       result = new SwigDirector_WidgetImpl();
95967     } catch (std::out_of_range& e) {
95968       {
95969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95970       };
95971     } catch (std::exception& e) {
95972       {
95973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95974       };
95975     } catch (...) {
95976       {
95977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95978       };
95979     }
95980   }
95981   jresult = result;
95982   return jresult;
95983 }
95984
95985
95986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
95987   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95988   std::string *arg2 = 0 ;
95989   Dali::Window arg3 ;
95990   Dali::Window *argp3 ;
95991
95992   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95993   if (!jarg2) {
95994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95995     return ;
95996   }
95997   std::string arg2_str(jarg2);
95998   arg2 = &arg2_str;
95999   argp3 = (Dali::Window *)jarg3;
96000   if (!argp3) {
96001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96002     return ;
96003   }
96004   arg3 = *argp3;
96005   {
96006     try {
96007       (arg1)->OnCreate((std::string const &)*arg2,arg3);
96008     } catch (std::out_of_range& e) {
96009       {
96010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96011       };
96012     } catch (std::exception& e) {
96013       {
96014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96015       };
96016     } catch (...) {
96017       {
96018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96019       };
96020     }
96021   }
96022 }
96023
96024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
96025   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96026   std::string *arg2 = 0 ;
96027   Dali::Window arg3 ;
96028   Dali::Window *argp3 ;
96029
96030   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96031   if (!jarg2) {
96032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96033     return ;
96034   }
96035   std::string arg2_str(jarg2);
96036   arg2 = &arg2_str;
96037   argp3 = (Dali::Window *)jarg3;
96038   if (!argp3) {
96039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96040     return ;
96041   }
96042   arg3 = *argp3;
96043   {
96044     try {
96045       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
96046     } catch (std::out_of_range& e) {
96047       {
96048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96049       };
96050     } catch (std::exception& e) {
96051       {
96052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96053       };
96054     } catch (...) {
96055       {
96056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96057       };
96058     }
96059   }
96060 }
96061
96062
96063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
96064   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96065   std::string *arg2 = 0 ;
96066   Dali::Widget::Termination arg3 ;
96067
96068   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96069   if (!jarg2) {
96070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96071     return ;
96072   }
96073   std::string arg2_str(jarg2);
96074   arg2 = &arg2_str;
96075   arg3 = (Dali::Widget::Termination)jarg3;
96076   {
96077     try {
96078       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
96079     } catch (std::out_of_range& e) {
96080       {
96081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96082       };
96083     } catch (std::exception& e) {
96084       {
96085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96086       };
96087     } catch (...) {
96088       {
96089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96090       };
96091     }
96092   }
96093 }
96094
96095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96096   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96097   std::string *arg2 = 0 ;
96098   Dali::Widget::Termination arg3 ;
96099
96100   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96101   if (!jarg2) {
96102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96103     return ;
96104   }
96105   std::string arg2_str(jarg2);
96106   arg2 = &arg2_str;
96107   arg3 = (Dali::Widget::Termination)jarg3;
96108   {
96109     try {
96110       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
96111     } catch (std::out_of_range& e) {
96112       {
96113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96114       };
96115     } catch (std::exception& e) {
96116       {
96117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96118       };
96119     } catch (...) {
96120       {
96121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96122       };
96123     }
96124   }
96125 }
96126
96127
96128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
96129   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96130
96131   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96132   {
96133     try {
96134       (arg1)->OnPause();
96135     } catch (std::out_of_range& e) {
96136       {
96137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96138       };
96139     } catch (std::exception& e) {
96140       {
96141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96142       };
96143     } catch (...) {
96144       {
96145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96146       };
96147     }
96148   }
96149 }
96150
96151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
96152   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96153
96154   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96155   {
96156     try {
96157       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
96158     } catch (std::out_of_range& e) {
96159       {
96160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96161       };
96162     } catch (std::exception& e) {
96163       {
96164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96165       };
96166     } catch (...) {
96167       {
96168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96169       };
96170     }
96171   }
96172 }
96173
96174
96175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
96176   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96177
96178   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96179   {
96180     try {
96181       (arg1)->OnResume();
96182     } catch (std::out_of_range& e) {
96183       {
96184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96185       };
96186     } catch (std::exception& e) {
96187       {
96188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96189       };
96190     } catch (...) {
96191       {
96192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96193       };
96194     }
96195   }
96196 }
96197
96198
96199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96200   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96201
96202   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96203   {
96204     try {
96205       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96206     } catch (std::out_of_range& e) {
96207       {
96208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96209       };
96210     } catch (std::exception& e) {
96211       {
96212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96213       };
96214     } catch (...) {
96215       {
96216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96217       };
96218     }
96219   }
96220 }
96221
96222
96223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96224   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96225   Dali::Window arg2 ;
96226   Dali::Window *argp2 ;
96227
96228   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96229   argp2 = (Dali::Window *)jarg2;
96230   if (!argp2) {
96231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96232     return ;
96233   }
96234   arg2 = *argp2;
96235   {
96236     try {
96237       (arg1)->OnResize(arg2);
96238     } catch (std::out_of_range& e) {
96239       {
96240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96241       };
96242     } catch (std::exception& e) {
96243       {
96244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96245       };
96246     } catch (...) {
96247       {
96248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96249       };
96250     }
96251   }
96252 }
96253
96254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96255   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96256   Dali::Window arg2 ;
96257   Dali::Window *argp2 ;
96258
96259   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96260   argp2 = (Dali::Window *)jarg2;
96261   if (!argp2) {
96262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96263     return ;
96264   }
96265   arg2 = *argp2;
96266   {
96267     try {
96268       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96269     } catch (std::out_of_range& e) {
96270       {
96271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96272       };
96273     } catch (std::exception& e) {
96274       {
96275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96276       };
96277     } catch (...) {
96278       {
96279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96280       };
96281     }
96282   }
96283 }
96284
96285
96286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96287   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96288   std::string *arg2 = 0 ;
96289   int arg3 ;
96290
96291   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96292   if (!jarg2) {
96293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96294     return ;
96295   }
96296   std::string arg2_str(jarg2);
96297   arg2 = &arg2_str;
96298   arg3 = (int)jarg3;
96299   {
96300     try {
96301       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96302     } catch (std::out_of_range& e) {
96303       {
96304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96305       };
96306     } catch (std::exception& e) {
96307       {
96308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96309       };
96310     } catch (...) {
96311       {
96312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96313       };
96314     }
96315   }
96316 }
96317
96318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96319   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96320   std::string *arg2 = 0 ;
96321   int arg3 ;
96322
96323   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96324   if (!jarg2) {
96325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96326     return ;
96327   }
96328   std::string arg2_str(jarg2);
96329   arg2 = &arg2_str;
96330   arg3 = (int)jarg3;
96331   {
96332     try {
96333       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96334     } catch (std::out_of_range& e) {
96335       {
96336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96337       };
96338     } catch (std::exception& e) {
96339       {
96340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96341       };
96342     } catch (...) {
96343       {
96344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96345       };
96346     }
96347   }
96348 }
96349
96350
96351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96352   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96353   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96354   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96355
96356   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96357   arg2 = (Dali::SlotObserver *)jarg2;
96358   arg3 = (Dali::CallbackBase *)jarg3;
96359   {
96360     try {
96361       (arg1)->SignalConnected(arg2,arg3);
96362     } catch (std::out_of_range& e) {
96363       {
96364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96365       };
96366     } catch (std::exception& e) {
96367       {
96368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96369       };
96370     } catch (...) {
96371       {
96372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96373       };
96374     }
96375   }
96376 }
96377
96378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96379   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96380   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96381   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96382
96383   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96384   arg2 = (Dali::SlotObserver *)jarg2;
96385   arg3 = (Dali::CallbackBase *)jarg3;
96386   {
96387     try {
96388       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96389     } catch (std::out_of_range& e) {
96390       {
96391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96392       };
96393     } catch (std::exception& e) {
96394       {
96395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96396       };
96397     } catch (...) {
96398       {
96399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96400       };
96401     }
96402   }
96403 }
96404
96405
96406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96407   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96408   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96409   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96410
96411   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96412   arg2 = (Dali::SlotObserver *)jarg2;
96413   arg3 = (Dali::CallbackBase *)jarg3;
96414   {
96415     try {
96416       (arg1)->SignalDisconnected(arg2,arg3);
96417     } catch (std::out_of_range& e) {
96418       {
96419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96420       };
96421     } catch (std::exception& e) {
96422       {
96423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96424       };
96425     } catch (...) {
96426       {
96427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96428       };
96429     }
96430   }
96431 }
96432
96433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96434   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96435   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96436   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96437
96438   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96439   arg2 = (Dali::SlotObserver *)jarg2;
96440   arg3 = (Dali::CallbackBase *)jarg3;
96441   {
96442     try {
96443       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96444     } catch (std::out_of_range& e) {
96445       {
96446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96447       };
96448     } catch (std::exception& e) {
96449       {
96450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96451       };
96452     } catch (...) {
96453       {
96454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96455       };
96456     }
96457   }
96458 }
96459
96460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96461   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96462   std::string *arg2 = 0 ;
96463
96464   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96465   if (!jarg2) {
96466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96467     return ;
96468   }
96469   std::string arg2_str(jarg2);
96470   arg2 = &arg2_str;
96471   {
96472     try {
96473       (arg1)->SetContentInfo((std::string const &)*arg2);
96474     } catch (std::out_of_range& e) {
96475       {
96476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96477       };
96478     } catch (std::exception& e) {
96479       {
96480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96481       };
96482     } catch (...) {
96483       {
96484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96485       };
96486     }
96487   }
96488 }
96489
96490
96491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96492   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96493   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96494
96495   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96496   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96497   {
96498     try {
96499       (arg1)->SetImpl(arg2);
96500     } catch (std::out_of_range& e) {
96501       {
96502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96503       };
96504     } catch (std::exception& e) {
96505       {
96506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96507       };
96508     } catch (...) {
96509       {
96510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96511       };
96512     }
96513   }
96514 }
96515
96516 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) {
96517
96518   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96519   if (director) {
96520     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96521   }
96522 }
96523
96524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96525   void * jresult ;
96526   Dali::Widget *arg1 = 0 ;
96527   SwigDirector_WidgetImpl *result = 0 ;
96528
96529   arg1 = (Dali::Widget *)jarg1;
96530   if (!arg1) {
96531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96532     return 0;
96533   }
96534   {
96535     try {
96536       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96537     } catch (std::out_of_range& e) {
96538       {
96539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96540       };
96541     } catch (std::exception& e) {
96542       {
96543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96544       };
96545     } catch (...) {
96546       {
96547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96548       };
96549     }
96550   }
96551
96552   jresult = (void *)result;
96553   return jresult;
96554 }
96555
96556
96557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96558   void * jresult ;
96559   int *arg1 = (int *) 0 ;
96560   char ***arg2 ;
96561   std::string *arg3 = 0 ;
96562   Dali::WidgetApplication result;
96563   {
96564     int index = 0;
96565     int length = 0;
96566     char *retPtr;
96567     char *nextPtr;
96568     argWidgetC = jarg1;
96569     argWidgetV = new char*[jarg1 + 1];
96570
96571     retPtr = strtok_r( jarg2, " ", &nextPtr);
96572     if( retPtr )
96573     {
96574       length = strlen(retPtr);
96575     }
96576     argWidgetV[index] = new char[length + 1];
96577     if( retPtr )
96578     {
96579       strncpy(argWidgetV[index], retPtr, length);
96580     }
96581     argWidgetV[index][length] = '\0';
96582     index++;
96583
96584     while (index < jarg1)
96585     {
96586       length = 0;
96587       retPtr = strtok_r(NULL, " ", &nextPtr);
96588       if( retPtr )
96589       {
96590         length = strlen(retPtr);
96591       }
96592       argWidgetV[index] = new char[length + 1];
96593       if( retPtr )
96594       {
96595         strncpy(argWidgetV[index], retPtr, length);
96596       }
96597       argWidgetV[index][length] = '\0';
96598       index++;
96599     }
96600
96601     argWidgetV[jarg1] = NULL;
96602     argWidgetC = jarg1;
96603
96604     arg1 = &argWidgetC;
96605     arg2 = &argWidgetV;
96606   }
96607
96608   if (!jarg3) {
96609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96610     return 0;
96611   }
96612   std::string arg3_str(jarg3);
96613   arg3 = &arg3_str;
96614   {
96615     try {
96616       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96617     } catch (std::out_of_range& e) {
96618       {
96619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96620       };
96621     } catch (std::exception& e) {
96622       {
96623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96624       };
96625     } catch (...) {
96626       {
96627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96628       };
96629     }
96630   }
96631   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96632
96633   return jresult;
96634 }
96635
96636
96637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96638   void * jresult ;
96639   Dali::WidgetApplication *result = 0 ;
96640
96641   {
96642     try {
96643       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96644     } catch (std::out_of_range& e) {
96645       {
96646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96647       };
96648     } catch (std::exception& e) {
96649       {
96650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96651       };
96652     } catch (...) {
96653       {
96654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96655       };
96656     }
96657   }
96658   jresult = (void *)result;
96659   return jresult;
96660 }
96661
96662
96663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96664   void * jresult ;
96665   Dali::WidgetApplication *arg1 = 0 ;
96666   Dali::WidgetApplication *result = 0 ;
96667
96668   arg1 = (Dali::WidgetApplication *)jarg1;
96669   if (!arg1) {
96670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96671     return 0;
96672   }
96673   {
96674     try {
96675       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
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_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96696   void * jresult ;
96697   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96698   Dali::WidgetApplication *arg2 = 0 ;
96699   Dali::WidgetApplication *result = 0 ;
96700
96701   arg1 = (Dali::WidgetApplication *)jarg1;
96702   arg2 = (Dali::WidgetApplication *)jarg2;
96703   if (!arg2) {
96704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96705     return 0;
96706   }
96707   {
96708     try {
96709       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96710     } catch (std::out_of_range& e) {
96711       {
96712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96713       };
96714     } catch (std::exception& e) {
96715       {
96716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96717       };
96718     } catch (...) {
96719       {
96720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96721       };
96722     }
96723   }
96724   jresult = (void *)result;
96725   return jresult;
96726 }
96727
96728
96729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96730   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96731
96732   arg1 = (Dali::WidgetApplication *)jarg1;
96733   {
96734     try {
96735       delete arg1;
96736       if( argWidgetV )
96737       {
96738         // free string data
96739         for( int i=0; i < argWidgetC+1; i++)
96740         {
96741           delete [] argWidgetV[i];
96742         }
96743         delete [] argWidgetV;
96744       }
96745     } catch (std::out_of_range& e) {
96746       {
96747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96748       };
96749     } catch (std::exception& e) {
96750       {
96751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96752       };
96753     } catch (...) {
96754       {
96755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96756       };
96757     }
96758   }
96759 }
96760
96761
96762 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96763 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96764
96765 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96766 {
96767   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96768   return *widget;
96769 }
96770
96771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96772   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96773   std::string *arg2 = 0 ;
96774
96775   arg1 = (Dali::WidgetApplication *)jarg1;
96776   if (!jarg2) {
96777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96778     return ;
96779   }
96780   std::string arg2_str(*jarg2);
96781   arg2 = &arg2_str;
96782
96783   if(!_CSharpCreateWidgetFunction)
96784   {
96785     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96786   }
96787
96788   {
96789     try {
96790       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96791     } catch (std::out_of_range& e) {
96792       {
96793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96794       };
96795     } catch (std::exception& e) {
96796       {
96797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96798       };
96799     } catch (...) {
96800       {
96801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96802       };
96803     }
96804   }
96805
96806   //Typemap argout in c++ file.
96807   //This will convert c++ string to c# string
96808   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96809 }
96810
96811
96812 //for PixelBuffer and ImageLoading
96813
96814 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96815     return (Dali::BaseHandle *)jarg1;
96816 }
96817
96818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
96819   void * jresult ;
96820   unsigned int arg1 ;
96821   unsigned int arg2 ;
96822   Dali::Pixel::Format arg3 ;
96823   Dali::Devel::PixelBuffer result;
96824
96825   arg1 = (unsigned int)jarg1;
96826   arg2 = (unsigned int)jarg2;
96827   arg3 = (Dali::Pixel::Format)jarg3;
96828   {
96829     try {
96830       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
96831     } catch (std::out_of_range& e) {
96832       {
96833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96834       };
96835     } catch (std::exception& e) {
96836       {
96837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96838       };
96839     } catch (...) {
96840       {
96841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96842       };
96843     }
96844   }
96845   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
96846   return jresult;
96847 }
96848
96849
96850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
96851   void * jresult ;
96852   Dali::Devel::PixelBuffer *result = 0 ;
96853
96854   {
96855     try {
96856       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
96857     } catch (std::out_of_range& e) {
96858       {
96859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96860       };
96861     } catch (std::exception& e) {
96862       {
96863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96864       };
96865     } catch (...) {
96866       {
96867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96868       };
96869     }
96870   }
96871   jresult = (void *)result;
96872   return jresult;
96873 }
96874
96875
96876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
96877   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96878
96879   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96880   {
96881     try {
96882       delete arg1;
96883     } catch (std::out_of_range& e) {
96884       {
96885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96886       };
96887     } catch (std::exception& e) {
96888       {
96889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96890       };
96891     } catch (...) {
96892       {
96893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96894       };
96895     }
96896   }
96897 }
96898
96899
96900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
96901   void * jresult ;
96902   Dali::Devel::PixelBuffer *arg1 = 0 ;
96903   Dali::Devel::PixelBuffer *result = 0 ;
96904
96905   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96906   if (!arg1) {
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 *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
96933   void * jresult ;
96934   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96935   Dali::Devel::PixelBuffer *arg2 = 0 ;
96936   Dali::Devel::PixelBuffer *result = 0 ;
96937
96938   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96939   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
96940   if (!arg2) {
96941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96942     return 0;
96943   }
96944   {
96945     try {
96946       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
96947     } catch (std::out_of_range& e) {
96948       {
96949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96950       };
96951     } catch (std::exception& e) {
96952       {
96953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96954       };
96955     } catch (...) {
96956       {
96957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96958       };
96959     }
96960   }
96961   jresult = (void *)result;
96962   return jresult;
96963 }
96964
96965
96966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
96967   void * jresult ;
96968   Dali::Devel::PixelBuffer *arg1 = 0 ;
96969   Dali::PixelData result;
96970
96971   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96972   if (!arg1) {
96973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
96974     return 0;
96975   }
96976   {
96977     try {
96978       result = Dali::Devel::PixelBuffer::Convert(*arg1);
96979     } catch (std::out_of_range& e) {
96980       {
96981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96982       };
96983     } catch (std::exception& e) {
96984       {
96985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96986       };
96987     } catch (...) {
96988       {
96989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96990       };
96991     }
96992   }
96993   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96994   return jresult;
96995 }
96996
96997
96998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
96999   void * jresult ;
97000   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97001   Dali::PixelData result;
97002
97003   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97004   {
97005     try {
97006       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
97007     } catch (std::out_of_range& e) {
97008       {
97009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97010       };
97011     } catch (std::exception& e) {
97012       {
97013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97014       };
97015     } catch (...) {
97016       {
97017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97018       };
97019     }
97020   }
97021   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97022   return jresult;
97023 }
97024
97025
97026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
97027   void * jresult ;
97028   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97029   unsigned char *result = 0 ;
97030
97031   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97032   {
97033     try {
97034       result = (unsigned char *)(arg1)->GetBuffer();
97035     } catch (std::out_of_range& e) {
97036       {
97037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97038       };
97039     } catch (std::exception& e) {
97040       {
97041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97042       };
97043     } catch (...) {
97044       {
97045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97046       };
97047     }
97048   }
97049   jresult = (void *)result;
97050   return jresult;
97051 }
97052
97053
97054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
97055   unsigned int jresult ;
97056   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97057   unsigned int result;
97058
97059   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97060   {
97061     try {
97062       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
97063     } catch (std::out_of_range& e) {
97064       {
97065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97066       };
97067     } catch (std::exception& e) {
97068       {
97069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97070       };
97071     } catch (...) {
97072       {
97073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97074       };
97075     }
97076   }
97077   jresult = result;
97078   return jresult;
97079 }
97080
97081
97082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
97083   unsigned int jresult ;
97084   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97085   unsigned int result;
97086
97087   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97088   {
97089     try {
97090       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
97091     } catch (std::out_of_range& e) {
97092       {
97093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97094       };
97095     } catch (std::exception& e) {
97096       {
97097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97098       };
97099     } catch (...) {
97100       {
97101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97102       };
97103     }
97104   }
97105   jresult = result;
97106   return jresult;
97107 }
97108
97109
97110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
97111   int jresult ;
97112   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97113   Dali::Pixel::Format result;
97114
97115   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97116   {
97117     try {
97118       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
97119     } catch (std::out_of_range& e) {
97120       {
97121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97122       };
97123     } catch (std::exception& e) {
97124       {
97125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97126       };
97127     } catch (...) {
97128       {
97129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97130       };
97131     }
97132   }
97133   jresult = (int)result;
97134   return jresult;
97135 }
97136
97137
97138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
97139   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97140   Dali::Devel::PixelBuffer arg2 ;
97141   float arg3 ;
97142   bool arg4 ;
97143   Dali::Devel::PixelBuffer *argp2 ;
97144
97145   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97146   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97147   if (!argp2) {
97148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97149     return ;
97150   }
97151   arg2 = *argp2;
97152   arg3 = (float)jarg3;
97153   arg4 = jarg4 ? true : false;
97154   {
97155     try {
97156       (arg1)->ApplyMask(arg2,arg3,arg4);
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_1(void * jarg1, void * jarg2, float jarg3) {
97175   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97176   Dali::Devel::PixelBuffer arg2 ;
97177   float arg3 ;
97178   Dali::Devel::PixelBuffer *argp2 ;
97179
97180   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97181   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97182   if (!argp2) {
97183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97184     return ;
97185   }
97186   arg2 = *argp2;
97187   arg3 = (float)jarg3;
97188   {
97189     try {
97190       (arg1)->ApplyMask(arg2,arg3);
97191     } catch (std::out_of_range& e) {
97192       {
97193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97194       };
97195     } catch (std::exception& e) {
97196       {
97197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97198       };
97199     } catch (...) {
97200       {
97201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97202       };
97203     }
97204   }
97205 }
97206
97207
97208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97209   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97210   Dali::Devel::PixelBuffer arg2 ;
97211   Dali::Devel::PixelBuffer *argp2 ;
97212
97213   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97214   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97215   if (!argp2) {
97216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97217     return ;
97218   }
97219   arg2 = *argp2;
97220   {
97221     try {
97222       (arg1)->ApplyMask(arg2);
97223     } catch (std::out_of_range& e) {
97224       {
97225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97226       };
97227     } catch (std::exception& e) {
97228       {
97229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97230       };
97231     } catch (...) {
97232       {
97233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97234       };
97235     }
97236   }
97237 }
97238
97239
97240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
97241   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97242   float arg2 ;
97243
97244   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97245   arg2 = (float)jarg2;
97246   {
97247     try {
97248       (arg1)->ApplyGaussianBlur(arg2);
97249     } catch (std::out_of_range& e) {
97250       {
97251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97252       };
97253     } catch (std::exception& e) {
97254       {
97255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97256       };
97257     } catch (...) {
97258       {
97259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97260       };
97261     }
97262   }
97263 }
97264
97265
97266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97267   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97268   uint16_t arg2 ;
97269   uint16_t arg3 ;
97270   uint16_t arg4 ;
97271   uint16_t arg5 ;
97272
97273   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97274   arg2 = (uint16_t)jarg2;
97275   arg3 = (uint16_t)jarg3;
97276   arg4 = (uint16_t)jarg4;
97277   arg5 = (uint16_t)jarg5;
97278   {
97279     try {
97280       (arg1)->Crop(arg2,arg3,arg4,arg5);
97281     } catch (std::out_of_range& e) {
97282       {
97283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97284       };
97285     } catch (std::exception& e) {
97286       {
97287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97288       };
97289     } catch (...) {
97290       {
97291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97292       };
97293     }
97294   }
97295 }
97296
97297
97298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97299   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97300   uint16_t arg2 ;
97301   uint16_t arg3 ;
97302
97303   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97304   arg2 = (uint16_t)jarg2;
97305   arg3 = (uint16_t)jarg3;
97306   {
97307     try {
97308       (arg1)->Resize(arg2,arg3);
97309     } catch (std::out_of_range& e) {
97310       {
97311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97312       };
97313     } catch (std::exception& e) {
97314       {
97315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97316       };
97317     } catch (...) {
97318       {
97319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97320       };
97321     }
97322   }
97323 }
97324
97325 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97326   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97327   Dali::Degree * arg2 ;
97328
97329   bool result = false;
97330
97331   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97332   arg2 = (Dali::Degree *)jarg2;
97333   {
97334     try {
97335       result = (arg1)->Rotate(*arg2);
97336     } catch (std::out_of_range& e) {
97337       {
97338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97339       };
97340     } catch (std::exception& e) {
97341       {
97342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97343       };
97344     } catch (...) {
97345       {
97346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97347       };
97348     }
97349   }
97350   return result;
97351 }
97352
97353
97354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97355   void * jresult ;
97356   std::string *arg1 = 0 ;
97357   Dali::ImageDimensions arg2 ;
97358   Dali::FittingMode::Type arg3 ;
97359   Dali::SamplingMode::Type arg4 ;
97360   bool arg5 ;
97361   Dali::ImageDimensions *argp2 ;
97362   Dali::Devel::PixelBuffer result;
97363
97364   if (!jarg1) {
97365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97366     return 0;
97367   }
97368   std::string arg1_str(jarg1);
97369   arg1 = &arg1_str;
97370   argp2 = (Dali::ImageDimensions *)jarg2;
97371   if (!argp2) {
97372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97373     return 0;
97374   }
97375   arg2 = *argp2;
97376   arg3 = (Dali::FittingMode::Type)jarg3;
97377   arg4 = (Dali::SamplingMode::Type)jarg4;
97378   arg5 = jarg5 ? true : false;
97379   {
97380     try {
97381       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97382     } catch (std::out_of_range& e) {
97383       {
97384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97385       };
97386     } catch (std::exception& e) {
97387       {
97388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97389       };
97390     } catch (...) {
97391       {
97392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97393       };
97394     }
97395   }
97396   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97397
97398   return jresult;
97399 }
97400
97401
97402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97403   void * jresult ;
97404   std::string *arg1 = 0 ;
97405   Dali::ImageDimensions arg2 ;
97406   Dali::FittingMode::Type arg3 ;
97407   Dali::SamplingMode::Type arg4 ;
97408   Dali::ImageDimensions *argp2 ;
97409   Dali::Devel::PixelBuffer result;
97410
97411   if (!jarg1) {
97412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97413     return 0;
97414   }
97415   std::string arg1_str(jarg1);
97416   arg1 = &arg1_str;
97417   argp2 = (Dali::ImageDimensions *)jarg2;
97418   if (!argp2) {
97419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97420     return 0;
97421   }
97422   arg2 = *argp2;
97423   arg3 = (Dali::FittingMode::Type)jarg3;
97424   arg4 = (Dali::SamplingMode::Type)jarg4;
97425   {
97426     try {
97427       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97428     } catch (std::out_of_range& e) {
97429       {
97430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97431       };
97432     } catch (std::exception& e) {
97433       {
97434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97435       };
97436     } catch (...) {
97437       {
97438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97439       };
97440     }
97441   }
97442   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97443
97444   return jresult;
97445 }
97446
97447
97448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97449   void * jresult ;
97450   std::string *arg1 = 0 ;
97451   Dali::ImageDimensions arg2 ;
97452   Dali::FittingMode::Type arg3 ;
97453   Dali::ImageDimensions *argp2 ;
97454   Dali::Devel::PixelBuffer result;
97455
97456   if (!jarg1) {
97457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97458     return 0;
97459   }
97460   std::string arg1_str(jarg1);
97461   arg1 = &arg1_str;
97462   argp2 = (Dali::ImageDimensions *)jarg2;
97463   if (!argp2) {
97464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97465     return 0;
97466   }
97467   arg2 = *argp2;
97468   arg3 = (Dali::FittingMode::Type)jarg3;
97469   {
97470     try {
97471       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97472     } catch (std::out_of_range& e) {
97473       {
97474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97475       };
97476     } catch (std::exception& e) {
97477       {
97478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97479       };
97480     } catch (...) {
97481       {
97482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97483       };
97484     }
97485   }
97486   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97487
97488   return jresult;
97489 }
97490
97491
97492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97493   void * jresult ;
97494   std::string *arg1 = 0 ;
97495   Dali::ImageDimensions arg2 ;
97496   Dali::ImageDimensions *argp2 ;
97497   Dali::Devel::PixelBuffer result;
97498
97499   if (!jarg1) {
97500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97501     return 0;
97502   }
97503   std::string arg1_str(jarg1);
97504   arg1 = &arg1_str;
97505   argp2 = (Dali::ImageDimensions *)jarg2;
97506   if (!argp2) {
97507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97508     return 0;
97509   }
97510   arg2 = *argp2;
97511   {
97512     try {
97513       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
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_LoadImageFromFile__SWIG_4(char * jarg1) {
97535   void * jresult ;
97536   std::string *arg1 = 0 ;
97537   Dali::Devel::PixelBuffer result;
97538
97539   if (!jarg1) {
97540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97541     return 0;
97542   }
97543   std::string arg1_str(jarg1);
97544   arg1 = &arg1_str;
97545   {
97546     try {
97547       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97548     } catch (std::out_of_range& e) {
97549       {
97550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97551       };
97552     } catch (std::exception& e) {
97553       {
97554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97555       };
97556     } catch (...) {
97557       {
97558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97559       };
97560     }
97561   }
97562   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97563
97564   return jresult;
97565 }
97566
97567
97568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97569   void * jresult ;
97570   std::string *arg1 = 0 ;
97571   Dali::ImageDimensions arg2 ;
97572   Dali::FittingMode::Type arg3 ;
97573   Dali::SamplingMode::Type arg4 ;
97574   bool arg5 ;
97575   Dali::ImageDimensions *argp2 ;
97576   Dali::ImageDimensions result;
97577
97578   if (!jarg1) {
97579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97580     return 0;
97581   }
97582   std::string arg1_str(jarg1);
97583   arg1 = &arg1_str;
97584   argp2 = (Dali::ImageDimensions *)jarg2;
97585   if (!argp2) {
97586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97587     return 0;
97588   }
97589   arg2 = *argp2;
97590   arg3 = (Dali::FittingMode::Type)jarg3;
97591   arg4 = (Dali::SamplingMode::Type)jarg4;
97592   arg5 = jarg5 ? true : false;
97593   {
97594     try {
97595       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97596     } catch (std::out_of_range& e) {
97597       {
97598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97599       };
97600     } catch (std::exception& e) {
97601       {
97602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97603       };
97604     } catch (...) {
97605       {
97606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97607       };
97608     }
97609   }
97610   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97611
97612   return jresult;
97613 }
97614
97615
97616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97617   void * jresult ;
97618   std::string *arg1 = 0 ;
97619   Dali::ImageDimensions arg2 ;
97620   Dali::FittingMode::Type arg3 ;
97621   Dali::SamplingMode::Type arg4 ;
97622   Dali::ImageDimensions *argp2 ;
97623   Dali::ImageDimensions result;
97624
97625   if (!jarg1) {
97626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97627     return 0;
97628   }
97629   std::string arg1_str(jarg1);
97630   arg1 = &arg1_str;
97631   argp2 = (Dali::ImageDimensions *)jarg2;
97632   if (!argp2) {
97633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97634     return 0;
97635   }
97636   arg2 = *argp2;
97637   arg3 = (Dali::FittingMode::Type)jarg3;
97638   arg4 = (Dali::SamplingMode::Type)jarg4;
97639   {
97640     try {
97641       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97642     } catch (std::out_of_range& e) {
97643       {
97644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97645       };
97646     } catch (std::exception& e) {
97647       {
97648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97649       };
97650     } catch (...) {
97651       {
97652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97653       };
97654     }
97655   }
97656   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97657
97658   return jresult;
97659 }
97660
97661
97662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97663   void * jresult ;
97664   std::string *arg1 = 0 ;
97665   Dali::ImageDimensions arg2 ;
97666   Dali::FittingMode::Type arg3 ;
97667   Dali::ImageDimensions *argp2 ;
97668   Dali::ImageDimensions result;
97669
97670   if (!jarg1) {
97671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97672     return 0;
97673   }
97674   std::string arg1_str(jarg1);
97675   arg1 = &arg1_str;
97676   argp2 = (Dali::ImageDimensions *)jarg2;
97677   if (!argp2) {
97678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97679     return 0;
97680   }
97681   arg2 = *argp2;
97682   arg3 = (Dali::FittingMode::Type)jarg3;
97683   {
97684     try {
97685       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97686     } catch (std::out_of_range& e) {
97687       {
97688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97689       };
97690     } catch (std::exception& e) {
97691       {
97692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97693       };
97694     } catch (...) {
97695       {
97696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97697       };
97698     }
97699   }
97700   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97701
97702   return jresult;
97703 }
97704
97705
97706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97707   void * jresult ;
97708   std::string *arg1 = 0 ;
97709   Dali::ImageDimensions arg2 ;
97710   Dali::ImageDimensions *argp2 ;
97711   Dali::ImageDimensions result;
97712
97713   if (!jarg1) {
97714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97715     return 0;
97716   }
97717   std::string arg1_str(jarg1);
97718   arg1 = &arg1_str;
97719   argp2 = (Dali::ImageDimensions *)jarg2;
97720   if (!argp2) {
97721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97722     return 0;
97723   }
97724   arg2 = *argp2;
97725   {
97726     try {
97727       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
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
97748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97749   void * jresult ;
97750   std::string *arg1 = 0 ;
97751   Dali::ImageDimensions result;
97752
97753   if (!jarg1) {
97754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97755     return 0;
97756   }
97757   std::string arg1_str(jarg1);
97758   arg1 = &arg1_str;
97759   {
97760     try {
97761       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97762     } catch (std::out_of_range& e) {
97763       {
97764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97765       };
97766     } catch (std::exception& e) {
97767       {
97768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97769       };
97770     } catch (...) {
97771       {
97772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97773       };
97774     }
97775   }
97776   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97777
97778   return jresult;
97779 }
97780
97781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97782   void * jresult ;
97783   std::string *arg1 = 0 ;
97784   Dali::ImageDimensions result;
97785
97786   if (!jarg1) {
97787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97788     return 0;
97789   }
97790   std::string arg1_str(jarg1);
97791   arg1 = &arg1_str;
97792   {
97793     try {
97794       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97795     } catch (std::out_of_range& e) {
97796       {
97797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97798       };
97799     } catch (std::exception& e) {
97800       {
97801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97802       };
97803     } catch (...) {
97804       {
97805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97806       };
97807     }
97808   }
97809   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97810
97811   return jresult;
97812 }
97813
97814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97815   void * jresult ;
97816   std::string *arg1 = 0 ;
97817   Dali::ImageDimensions arg2 ;
97818   Dali::FittingMode::Type arg3 ;
97819   Dali::SamplingMode::Type arg4 ;
97820   bool arg5 ;
97821   Dali::ImageDimensions *argp2 ;
97822   Dali::Devel::PixelBuffer result;
97823
97824   if (!jarg1) {
97825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97826     return 0;
97827   }
97828   std::string arg1_str(jarg1);
97829   arg1 = &arg1_str;
97830   argp2 = (Dali::ImageDimensions *)jarg2;
97831   if (!argp2) {
97832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97833     return 0;
97834   }
97835   arg2 = *argp2;
97836   arg3 = (Dali::FittingMode::Type)jarg3;
97837   arg4 = (Dali::SamplingMode::Type)jarg4;
97838   arg5 = jarg5 ? true : false;
97839   {
97840     try {
97841       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97842     } catch (std::out_of_range& e) {
97843       {
97844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97845       };
97846     } catch (std::exception& e) {
97847       {
97848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97849       };
97850     } catch (...) {
97851       {
97852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97853       };
97854     }
97855   }
97856   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97857
97858   return jresult;
97859 }
97860
97861
97862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97863   void * jresult ;
97864   std::string *arg1 = 0 ;
97865   Dali::ImageDimensions arg2 ;
97866   Dali::FittingMode::Type arg3 ;
97867   Dali::SamplingMode::Type arg4 ;
97868   Dali::ImageDimensions *argp2 ;
97869   Dali::Devel::PixelBuffer result;
97870
97871   if (!jarg1) {
97872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97873     return 0;
97874   }
97875   std::string arg1_str(jarg1);
97876   arg1 = &arg1_str;
97877   argp2 = (Dali::ImageDimensions *)jarg2;
97878   if (!argp2) {
97879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97880     return 0;
97881   }
97882   arg2 = *argp2;
97883   arg3 = (Dali::FittingMode::Type)jarg3;
97884   arg4 = (Dali::SamplingMode::Type)jarg4;
97885   {
97886     try {
97887       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
97888     } catch (std::out_of_range& e) {
97889       {
97890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97891       };
97892     } catch (std::exception& e) {
97893       {
97894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97895       };
97896     } catch (...) {
97897       {
97898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97899       };
97900     }
97901   }
97902   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97903
97904   return jresult;
97905 }
97906
97907
97908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97909   void * jresult ;
97910   std::string *arg1 = 0 ;
97911   Dali::ImageDimensions arg2 ;
97912   Dali::FittingMode::Type arg3 ;
97913   Dali::ImageDimensions *argp2 ;
97914   Dali::Devel::PixelBuffer result;
97915
97916   if (!jarg1) {
97917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97918     return 0;
97919   }
97920   std::string arg1_str(jarg1);
97921   arg1 = &arg1_str;
97922   argp2 = (Dali::ImageDimensions *)jarg2;
97923   if (!argp2) {
97924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97925     return 0;
97926   }
97927   arg2 = *argp2;
97928   arg3 = (Dali::FittingMode::Type)jarg3;
97929   {
97930     try {
97931       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
97932     } catch (std::out_of_range& e) {
97933       {
97934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97935       };
97936     } catch (std::exception& e) {
97937       {
97938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97939       };
97940     } catch (...) {
97941       {
97942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97943       };
97944     }
97945   }
97946   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97947
97948   return jresult;
97949 }
97950
97951
97952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
97953   void * jresult ;
97954   std::string *arg1 = 0 ;
97955   Dali::ImageDimensions arg2 ;
97956   Dali::ImageDimensions *argp2 ;
97957   Dali::Devel::PixelBuffer result;
97958
97959   if (!jarg1) {
97960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97961     return 0;
97962   }
97963   std::string arg1_str(jarg1);
97964   arg1 = &arg1_str;
97965   argp2 = (Dali::ImageDimensions *)jarg2;
97966   if (!argp2) {
97967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97968     return 0;
97969   }
97970   arg2 = *argp2;
97971   {
97972     try {
97973       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
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_DownloadImageSynchronously__SWIG_4(char * jarg1) {
97995   void * jresult ;
97996   std::string *arg1 = 0 ;
97997   Dali::Devel::PixelBuffer result;
97998
97999   if (!jarg1) {
98000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98001     return 0;
98002   }
98003   std::string arg1_str(jarg1);
98004   arg1 = &arg1_str;
98005   {
98006     try {
98007       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
98008     } catch (std::out_of_range& e) {
98009       {
98010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98011       };
98012     } catch (std::exception& e) {
98013       {
98014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98015       };
98016     } catch (...) {
98017       {
98018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98019       };
98020     }
98021   }
98022   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98023
98024   return jresult;
98025 }
98026
98027
98028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
98029   void * jresult ;
98030   Dali::Toolkit::WebView result;
98031
98032   {
98033     try {
98034       result = Dali::Toolkit::WebView::New();
98035     } catch (std::out_of_range& e) {
98036       {
98037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98038       };
98039     } catch (std::exception& e) {
98040       {
98041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98042       };
98043     } catch (Dali::DaliException e) {
98044       {
98045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98046       };
98047     } catch (...) {
98048       {
98049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98050       };
98051     }
98052   }
98053   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98054   return jresult;
98055 }
98056
98057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
98058   void * jresult ;
98059   Dali::Toolkit::WebView result;
98060
98061   std::string *arg1;
98062   std::string *arg2;
98063
98064   if (!jarg1) {
98065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
98066     return 0;
98067   }
98068   if (!jarg2) {
98069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
98070     return 0;
98071   }
98072
98073   std::string jarg1_str = std::string(jarg1);
98074   std::string jarg2_str = std::string(jarg2);
98075
98076   arg1 = &jarg1_str;
98077   arg2 = &jarg2_str;
98078
98079   {
98080     try {
98081       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
98082     } catch (std::out_of_range& e) {
98083       {
98084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98085       };
98086     } catch (std::exception& e) {
98087       {
98088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98089       };
98090     } catch (Dali::DaliException e) {
98091       {
98092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98093       };
98094     } catch (...) {
98095       {
98096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98097       };
98098     }
98099   }
98100   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98101   return jresult;
98102 }
98103
98104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
98105   void * jresult ;
98106   Dali::Toolkit::WebView *arg1 = 0 ;
98107   Dali::Toolkit::WebView *result = 0 ;
98108
98109   arg1 = (Dali::Toolkit::WebView *)jarg1;
98110   if (!arg1) {
98111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98112     return 0;
98113   }
98114   {
98115     try {
98116       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
98117     } catch (std::out_of_range& e) {
98118       {
98119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98120       };
98121     } catch (std::exception& e) {
98122       {
98123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98124       };
98125     } catch (Dali::DaliException e) {
98126       {
98127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98128       };
98129     } catch (...) {
98130       {
98131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98132       };
98133     }
98134   }
98135   jresult = (void *)result;
98136   return jresult;
98137 }
98138
98139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
98140   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98141   arg1 = (Dali::Toolkit::WebView *)jarg1;
98142   {
98143     try {
98144       delete arg1;
98145     } catch (std::out_of_range& e) {
98146       {
98147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98148       };
98149     } catch (std::exception& e) {
98150       {
98151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98152       };
98153     } catch (Dali::DaliException e) {
98154       {
98155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98156       };
98157     } catch (...) {
98158       {
98159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98160       };
98161     }
98162   }
98163 }
98164
98165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
98166   void * jresult ;
98167   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98168   Dali::Toolkit::WebView *arg2 = 0 ;
98169   Dali::Toolkit::WebView *result = 0 ;
98170
98171   arg1 = (Dali::Toolkit::WebView *)jarg1;
98172   arg2 = (Dali::Toolkit::WebView *)jarg2;
98173   if (!arg2) {
98174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98175     return 0;
98176   }
98177   {
98178     try {
98179       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98180     } catch (std::out_of_range& e) {
98181       {
98182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98183       };
98184     } catch (std::exception& e) {
98185       {
98186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98187       };
98188     } catch (Dali::DaliException e) {
98189       {
98190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98191       };
98192     } catch (...) {
98193       {
98194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98195       };
98196     }
98197   }
98198   jresult = (void *)result;
98199   return jresult;
98200 }
98201
98202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98203   void * jresult ;
98204   Dali::BaseHandle arg1 ;
98205   Dali::BaseHandle *argp1 ;
98206   Dali::Toolkit::WebView result;
98207
98208   argp1 = (Dali::BaseHandle *)jarg1;
98209   if (!argp1) {
98210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98211     return 0;
98212   }
98213   arg1 = *argp1;
98214   {
98215     try {
98216       result = Dali::Toolkit::WebView::DownCast(arg1);
98217     } catch (std::out_of_range& e) {
98218       {
98219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98220       };
98221     } catch (std::exception& e) {
98222       {
98223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98224       };
98225     } catch (Dali::DaliException e) {
98226       {
98227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98228       };
98229     } catch (...) {
98230       {
98231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98232       };
98233     }
98234   }
98235   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98236   return jresult;
98237 }
98238
98239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98240   return (int) Dali::Toolkit::WebView::Property::URL;
98241 }
98242
98243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98244   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98245 }
98246
98247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98248   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98249 }
98250
98251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98252   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98253 }
98254
98255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98256   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98257 }
98258
98259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98260   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98261 }
98262
98263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98264   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98265 }
98266
98267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98268   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98269 }
98270
98271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98272   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98273   std::string *arg2;
98274
98275   arg1 = (Dali::Toolkit::WebView *)jarg1;
98276
98277   if (!jarg2) {
98278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98279     return;
98280   }
98281
98282   std::string jarg2str = std::string(jarg2);
98283   arg2 = &jarg2str;
98284   {
98285     try {
98286       (arg1)->LoadUrl((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_LoadHTMLString(void * jarg1, char * jarg2) {
98308   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98309   std::string *arg2;
98310
98311   arg1 = (Dali::Toolkit::WebView *)jarg1;
98312   if (!jarg2) {
98313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98314     return;
98315   }
98316   std::string jarg2str = std::string(jarg2);
98317   arg2 = &jarg2str;
98318   {
98319     try {
98320       (arg1)->LoadHTMLString((std::string const &)*arg2);
98321     } catch (std::out_of_range& e) {
98322       {
98323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98324       };
98325     } catch (std::exception& e) {
98326       {
98327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98328       };
98329     } catch (Dali::DaliException e) {
98330       {
98331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98332       };
98333     } catch (...) {
98334       {
98335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98336       };
98337     }
98338   }
98339 }
98340
98341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98342   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98343
98344   arg1 = (Dali::Toolkit::WebView *)jarg1;
98345   {
98346     try {
98347       (arg1)->Reload();
98348     } catch (std::out_of_range& e) {
98349       {
98350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98351       };
98352     } catch (std::exception& e) {
98353       {
98354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98355       };
98356     } catch (Dali::DaliException e) {
98357       {
98358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98359       };
98360     } catch (...) {
98361       {
98362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98363       };
98364     }
98365   }
98366 }
98367
98368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98369   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98370
98371   arg1 = (Dali::Toolkit::WebView *)jarg1;
98372   {
98373     try {
98374       (arg1)->StopLoading();
98375     } catch (std::out_of_range& e) {
98376       {
98377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98378       };
98379     } catch (std::exception& e) {
98380       {
98381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98382       };
98383     } catch (Dali::DaliException e) {
98384       {
98385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98386       };
98387     } catch (...) {
98388       {
98389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98390       };
98391     }
98392   }
98393 }
98394
98395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98396   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98397
98398   arg1 = (Dali::Toolkit::WebView *)jarg1;
98399   {
98400     try {
98401       (arg1)->Suspend();
98402     } catch (std::out_of_range& e) {
98403       {
98404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98405       };
98406     } catch (std::exception& e) {
98407       {
98408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98409       };
98410     } catch (Dali::DaliException e) {
98411       {
98412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98413       };
98414     } catch (...) {
98415       {
98416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98417       };
98418     }
98419   }
98420 }
98421
98422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98423   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98424
98425   arg1 = (Dali::Toolkit::WebView *)jarg1;
98426   {
98427     try {
98428       (arg1)->Resume();
98429     } catch (std::out_of_range& e) {
98430       {
98431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98432       };
98433     } catch (std::exception& e) {
98434       {
98435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98436       };
98437     } catch (Dali::DaliException e) {
98438       {
98439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98440       };
98441     } catch (...) {
98442       {
98443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98444       };
98445     }
98446   }
98447 }
98448
98449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98450   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98451
98452   arg1 = (Dali::Toolkit::WebView *)jarg1;
98453   {
98454     try {
98455       (arg1)->GoBack();
98456     } catch (std::out_of_range& e) {
98457       {
98458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98459       };
98460     } catch (std::exception& e) {
98461       {
98462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98463       };
98464     } catch (Dali::DaliException e) {
98465       {
98466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98467       };
98468     } catch (...) {
98469       {
98470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98471       };
98472     }
98473   }
98474 }
98475
98476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98477   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98478
98479   arg1 = (Dali::Toolkit::WebView *)jarg1;
98480   {
98481     try {
98482       (arg1)->GoForward();
98483     } catch (std::out_of_range& e) {
98484       {
98485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98486       };
98487     } catch (std::exception& e) {
98488       {
98489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98490       };
98491     } catch (Dali::DaliException e) {
98492       {
98493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98494       };
98495     } catch (...) {
98496       {
98497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98498       };
98499     }
98500   }
98501 }
98502
98503 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98504   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98505   bool ret;
98506
98507   arg1 = (Dali::Toolkit::WebView *)jarg1;
98508   {
98509     try {
98510       ret = (arg1)->CanGoBack();
98511     } catch (std::out_of_range& e) {
98512       {
98513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98514       };
98515     } catch (std::exception& e) {
98516       {
98517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98518       };
98519     } catch (Dali::DaliException e) {
98520       {
98521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98522       };
98523     } catch (...) {
98524       {
98525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98526       };
98527     }
98528   }
98529   return ret;
98530 }
98531
98532 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98533   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98534   bool ret;
98535
98536   arg1 = (Dali::Toolkit::WebView *)jarg1;
98537   {
98538     try {
98539       ret = (arg1)->CanGoForward();
98540     } catch (std::out_of_range& e) {
98541       {
98542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98543       };
98544     } catch (std::exception& e) {
98545       {
98546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98547       };
98548     } catch (Dali::DaliException e) {
98549       {
98550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98551       };
98552     } catch (...) {
98553       {
98554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98555       };
98556     }
98557   }
98558   return ret;
98559 }
98560
98561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98562   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98563   std::string *arg2;
98564
98565   arg1 = (Dali::Toolkit::WebView *)jarg1;
98566   if (!jarg2) {
98567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98568     return;
98569   }
98570   std::string jarg2_str = std::string(jarg2);
98571   arg2 = &jarg2_str;
98572
98573   {
98574     try {
98575       if (jarg3) {
98576         void (*handler)(char*) = (void (*)(char*)) jarg3;
98577         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98578           handler(SWIG_csharp_string_callback(result.c_str()));
98579         });
98580       } else {
98581         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98582       }
98583     } catch (std::out_of_range& e) {
98584       {
98585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98586       };
98587     } catch (std::exception& e) {
98588       {
98589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98590       };
98591     } catch (Dali::DaliException e) {
98592       {
98593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98594       };
98595     } catch (...) {
98596       {
98597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98598       };
98599     }
98600   }
98601 }
98602
98603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98604 {
98605   if (!jarg2) {
98606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98607     return;
98608   }
98609
98610   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98611   std::string exposedObjectName = jarg2;
98612   void (*handler)(char*) = (void (*)(char*)) jarg3;
98613
98614   {
98615     try {
98616       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98617         handler(SWIG_csharp_string_callback(message.c_str()));
98618       });
98619     } catch (std::out_of_range& e) {
98620       {
98621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98622       };
98623     } catch (std::exception& e) {
98624       {
98625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98626       };
98627     } catch (Dali::DaliException e) {
98628       {
98629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98630       };
98631     } catch (...) {
98632       {
98633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98634       };
98635     }
98636   }
98637 }
98638
98639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98640   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98641
98642   arg1 = (Dali::Toolkit::WebView *)jarg1;
98643   {
98644     try {
98645       (arg1)->ClearHistory();
98646     } catch (std::out_of_range& e) {
98647       {
98648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98649       };
98650     } catch (std::exception& e) {
98651       {
98652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98653       };
98654     } catch (Dali::DaliException e) {
98655       {
98656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98657       };
98658     } catch (...) {
98659       {
98660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98661       };
98662     }
98663   }
98664 }
98665
98666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98667   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98668
98669   arg1 = (Dali::Toolkit::WebView *)jarg1;
98670   {
98671     try {
98672       (arg1)->ClearCache();
98673     } catch (std::out_of_range& e) {
98674       {
98675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98676       };
98677     } catch (std::exception& e) {
98678       {
98679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98680       };
98681     } catch (Dali::DaliException e) {
98682       {
98683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98684       };
98685     } catch (...) {
98686       {
98687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98688       };
98689     }
98690   }
98691 }
98692
98693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98694   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98695
98696   arg1 = (Dali::Toolkit::WebView *)jarg1;
98697   {
98698     try {
98699       (arg1)->ClearCookies();
98700     } catch (std::out_of_range& e) {
98701       {
98702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98703       };
98704     } catch (std::exception& e) {
98705       {
98706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98707       };
98708     } catch (Dali::DaliException e) {
98709       {
98710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98711       };
98712     } catch (...) {
98713       {
98714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98715       };
98716     }
98717   }
98718 }
98719
98720 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98721     return (Dali::Toolkit::Control *)jarg1;
98722 }
98723
98724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98725   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98726   SignalConverter::WebViewPageLoadSignal* result = NULL;
98727   {
98728     try {
98729       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98730     } catch (std::out_of_range& e) {
98731       {
98732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98733       };
98734     } catch (std::exception& e) {
98735       {
98736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98737       };
98738     } catch (Dali::DaliException e) {
98739       {
98740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98741       };
98742     } catch (...) {
98743       {
98744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98745       };
98746     }
98747   }
98748   return (void*) result;
98749 }
98750
98751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98752   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98753   SignalConverter::WebViewPageLoadSignal* result = NULL;
98754   {
98755     try {
98756       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98757     } catch (std::out_of_range& e) {
98758       {
98759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98760       };
98761     } catch (std::exception& e) {
98762       {
98763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98764       };
98765     } catch (Dali::DaliException e) {
98766       {
98767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98768       };
98769     } catch (...) {
98770       {
98771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98772       };
98773     }
98774   }
98775   return (void*) result;
98776 }
98777
98778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98779 {
98780   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98781   {
98782     try {
98783       delete object;
98784     } catch (std::out_of_range& e) {
98785       {
98786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98787       };
98788     } catch (std::exception& e) {
98789       {
98790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98791       };
98792     } catch (Dali::DaliException e) {
98793       {
98794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98795       };
98796     } catch (...) {
98797       {
98798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98799       };
98800     }
98801   }
98802 }
98803
98804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98805 {
98806   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98807   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98808   {
98809     try {
98810       proxy->Connect(callback);
98811     } catch (std::out_of_range& e) {
98812       {
98813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98814       };
98815     } catch (std::exception& e) {
98816       {
98817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98818       };
98819     } catch (Dali::DaliException e) {
98820       {
98821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98822       };
98823     } catch (...) {
98824       {
98825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98826       };
98827     }
98828   }
98829 }
98830
98831
98832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
98833   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98834   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98835   {
98836     try {
98837       proxy->Disconnect(callback);
98838     } catch (std::out_of_range& e) {
98839       {
98840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98841       };
98842     } catch (std::exception& e) {
98843       {
98844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98845       };
98846     } catch (Dali::DaliException e) {
98847       {
98848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98849       };
98850     } catch (...) {
98851       {
98852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98853       };
98854     }
98855   }
98856 }
98857
98858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
98859   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98860   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
98861   {
98862     try {
98863       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
98864     } catch (std::out_of_range& e) {
98865       {
98866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98867       };
98868     } catch (std::exception& e) {
98869       {
98870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98871       };
98872     } catch (Dali::DaliException e) {
98873       {
98874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98875       };
98876     } catch (...) {
98877       {
98878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98879       };
98880     }
98881   }
98882   return (void*) result;
98883 }
98884
98885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
98886 {
98887   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98888   {
98889     try {
98890       delete object;
98891     } catch (std::out_of_range& e) {
98892       {
98893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98894       };
98895     } catch (std::exception& e) {
98896       {
98897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98898       };
98899     } catch (Dali::DaliException e) {
98900       {
98901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98902       };
98903     } catch (...) {
98904       {
98905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98906       };
98907     }
98908   }
98909 }
98910
98911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
98912 {
98913   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98914   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98915   {
98916     try {
98917       proxy->Connect(callback);
98918     } catch (std::out_of_range& e) {
98919       {
98920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98921       };
98922     } catch (std::exception& e) {
98923       {
98924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98925       };
98926     } catch (Dali::DaliException e) {
98927       {
98928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98929       };
98930     } catch (...) {
98931       {
98932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98933       };
98934     }
98935   }
98936 }
98937
98938
98939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
98940   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98941   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98942   {
98943     try {
98944       proxy->Disconnect(callback);
98945     } catch (std::out_of_range& e) {
98946       {
98947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98948       };
98949     } catch (std::exception& e) {
98950       {
98951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98952       };
98953     } catch (Dali::DaliException e) {
98954       {
98955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98956       };
98957     } catch (...) {
98958       {
98959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98960       };
98961     }
98962   }
98963 }
98964
98965 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
98966   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
98967   char * jresult = SWIG_csharp_string_callback((const char *)result);
98968   return jresult;
98969 }
98970
98971 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
98972   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
98973   return result;
98974 }
98975
98976
98977 struct NativeImageSourcePtrHandle
98978 {
98979   NativeImageSourcePtr Ptr;
98980 };
98981
98982 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
98983 {
98984   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98985   return (NativeImageInterface*)(arg1);
98986 }
98987
98988 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
98989 {
98990   void* jresult;
98991   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
98992   {
98993     try {
98994       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
98995     }
98996     catch (std::out_of_range & e) {
98997       {
98998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98999       };
99000     }
99001     catch (std::exception & e) {
99002       {
99003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99004       };
99005     }
99006     catch (Dali::DaliException e) {
99007       {
99008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99009       };
99010     }
99011     catch (...) {
99012       {
99013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99014       };
99015     }
99016   }
99017   jresult = (void *)handle;
99018   return jresult;
99019 }
99020
99021 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
99022 {
99023   void* jresult;
99024   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
99025   jresult = (void*)( handle->Ptr.Get() );
99026   return jresult;
99027 }
99028
99029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
99030   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
99031   {
99032     try {
99033       delete arg1;
99034     }
99035     catch (std::out_of_range & e) {
99036       {
99037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
99038       };
99039     }
99040     catch (std::exception & e) {
99041       {
99042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
99043       };
99044     }
99045     catch (Dali::DaliException e) {
99046       {
99047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
99048       };
99049     }
99050     catch (...) {
99051       {
99052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
99053       };
99054     }
99055   }
99056 }
99057
99058 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
99059 {
99060   void* jresult;
99061   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99062   uint16_t* arg2 = (uint16_t*)(jarg2);
99063   uint16_t* arg3 = (uint16_t*)(jarg3);
99064   uint16_t* arg4 = (uint16_t*)(jarg4);
99065   {
99066     try {
99067       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
99068     }
99069     catch (std::out_of_range & e) {
99070       {
99071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99072       };
99073     }
99074     catch (std::exception & e) {
99075       {
99076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99077       };
99078     }
99079     catch (Dali::DaliException e) {
99080       {
99081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99082       };
99083     }
99084     catch (...) {
99085       {
99086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99087       };
99088     }
99089   }
99090   return jresult;
99091 }
99092
99093 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
99094 {
99095   bool jresult;
99096   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99097
99098   {
99099     try {
99100       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
99101     }
99102     catch (std::out_of_range & e) {
99103       {
99104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99105       };
99106     }
99107     catch (std::exception & e) {
99108       {
99109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99110       };
99111     }
99112     catch (Dali::DaliException e) {
99113       {
99114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99115       };
99116     }
99117     catch (...) {
99118       {
99119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99120       };
99121     }
99122   }
99123   return jresult;
99124 }
99125
99126
99127 #ifdef __cplusplus
99128 }
99129 #endif