dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 457 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 458 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 459
 460 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 461 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 462 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 463
 464 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 465 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 466 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 467
 468 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 469 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 470 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 471
 472 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 473
 474 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 475 #include <dali/devel-api/adaptor-framework/image-loading.h>
 476
 477 #include <dali/public-api/events/mouse-button.h>
 478
 479 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 480 #include "web-view-signal-converter.h"
 481
 482 #include <dali/integration-api/debug.h>
 483
 484 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 485
 486 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 487
 488
 489 // add here SWIG version check
 490
 491 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 492 // disable Swig-dependent warnings
 493
 494 // 'identifier1' has C-linkage specified,
 495 // but returns UDT 'identifier2' which is incompatible with C
 496 #pragma warning(disable: 4190)
 497
 498 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 499 #pragma warning(disable: 4800)
 500
 501 // debug info too long etc etc
 502 #pragma warning(disable: 4786)
 503 #endif
 504
 505
 506 #include <stdexcept>
 507
 508
 509 #include <string>
 510
 511
 512 #include <vector>
 513 #include <algorithm>
 514 #include <stdexcept>
 515
 516
 517 #include <map>
 518 #include <algorithm>
 519 #include <stdexcept>
 520
 521
 522 #include <utility>
 523
 524
 525 typedef float floatp;
 526
 527 SWIGINTERN floatp *new_floatp(){
 528   return new float();
 529 }
 530 SWIGINTERN void delete_floatp(floatp *self){
 531   if (self) delete self;
 532 }
 533 SWIGINTERN void floatp_assign(floatp *self,float value){
 534   *self = value;
 535 }
 536 SWIGINTERN float floatp_value(floatp *self){
 537   return *self;
 538 }
 539 SWIGINTERN float *floatp_cast(floatp *self){
 540   return self;
 541 }
 542 SWIGINTERN floatp *floatp_frompointer(float *t){
 543   return (floatp *) t;
 544 }
 545
 546 typedef int intp;
 547
 548 SWIGINTERN intp *new_intp(){
 549   return new int();
 550 }
 551 SWIGINTERN void delete_intp(intp *self){
 552   if (self) delete self;
 553 }
 554 SWIGINTERN void intp_assign(intp *self,int value){
 555   *self = value;
 556 }
 557 SWIGINTERN int intp_value(intp *self){
 558   return *self;
 559 }
 560 SWIGINTERN int *intp_cast(intp *self){
 561   return self;
 562 }
 563 SWIGINTERN intp *intp_frompointer(int *t){
 564   return (intp *) t;
 565 }
 566
 567 typedef double doublep;
 568
 569 SWIGINTERN doublep *new_doublep(){
 570   return new double();
 571 }
 572 SWIGINTERN void delete_doublep(doublep *self){
 573   if (self) delete self;
 574 }
 575 SWIGINTERN void doublep_assign(doublep *self,double value){
 576   *self = value;
 577 }
 578 SWIGINTERN double doublep_value(doublep *self){
 579   return *self;
 580 }
 581 SWIGINTERN double *doublep_cast(doublep *self){
 582   return self;
 583 }
 584 SWIGINTERN doublep *doublep_frompointer(double *t){
 585   return (doublep *) t;
 586 }
 587
 588 typedef unsigned int uintp;
 589
 590 SWIGINTERN uintp *new_uintp(){
 591   return new unsigned int();
 592 }
 593 SWIGINTERN void delete_uintp(uintp *self){
 594   if (self) delete self;
 595 }
 596 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 597   *self = value;
 598 }
 599 SWIGINTERN unsigned int uintp_value(uintp *self){
 600   return *self;
 601 }
 602 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 603   return self;
 604 }
 605 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 606   return (uintp *) t;
 607 }
 608
 609 typedef unsigned short ushortp;
 610
 611 SWIGINTERN ushortp *new_ushortp(){
 612   return new unsigned short();
 613 }
 614 SWIGINTERN void delete_ushortp(ushortp *self){
 615   if (self) delete self;
 616 }
 617 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 618   *self = value;
 619 }
 620 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 621   return *self;
 622 }
 623 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 624   return self;
 625 }
 626 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 627   return (ushortp *) t;
 628 }
 629
 630 unsigned int int_to_uint(int x) {
 631    return (unsigned int) x;
 632 }
 633
 634
 635 using namespace Dali;
 636 using namespace Dali::Toolkit;
 637
 638 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 639 {
 640   bool result = false;
 641   try
 642   {
 643     // C++ code. DALi uses Handle <-> Body design pattern.
 644     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 645     // Handles in DALi can be converted into a boolean type
 646     // to check if the handle has a valid body attached to it.
 647     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 648     if( *self )
 649     {
 650       result = true;
 651     }
 652     else
 653     {
 654       result = false;
 655     }
 656   }
 657   catch (std::out_of_range& e)
 658   {
 659     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 660     return 0;
 661   }
 662   catch (std::exception& e)
 663   {
 664     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 665     return 0;
 666   }
 667   catch (DaliException e)
 668   {
 669     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 670     return 0;
 671   }
 672   catch (...)
 673   {
 674     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 675     return 0;
 676   }
 677   return result;
 678 }
 679
 680 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 681 {
 682   bool result = false;
 683   try
 684   {
 685     // C++ code. Check if two handles reference the same implemtion
 686     if( *self == rhs)
 687     {
 688       result = true;
 689     }
 690     else
 691     {
 692       result = false;
 693     }
 694   }
 695   catch (std::out_of_range& e)
 696   {
 697     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 698     return 0;
 699   }
 700   catch (std::exception& e)
 701   {
 702     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 703     return 0;
 704   }
 705   catch (DaliException e)
 706   {
 707     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 708     return 0;
 709   }
 710   catch (...)
 711   {
 712     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 713     return 0;
 714   }
 715   return result;
 716 }
 717
 718
 719 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 720      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 721    }
 722 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){
 723      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 724    }
 725 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 726         std::vector< Dali::TouchPoint >* pv = 0;
 727         if (capacity >= 0) {
 728           pv = new std::vector< Dali::TouchPoint >();
 729           pv->reserve(capacity);
 730        } else {
 731           throw std::out_of_range("capacity");
 732        }
 733        return pv;
 734       }
 735 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 736         if (index>=0 && index<(int)self->size())
 737           return (*self)[index];
 738         else
 739           throw std::out_of_range("index");
 740       }
 741 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 742         if (index>=0 && index<(int)self->size())
 743           return (*self)[index];
 744         else
 745           throw std::out_of_range("index");
 746       }
 747 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 748         if (index>=0 && index<(int)self->size())
 749           (*self)[index] = val;
 750         else
 751           throw std::out_of_range("index");
 752       }
 753 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 754         self->insert(self->end(), values.begin(), values.end());
 755       }
 756 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 757         if (index < 0)
 758           throw std::out_of_range("index");
 759         if (count < 0)
 760           throw std::out_of_range("count");
 761         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 762           throw std::invalid_argument("invalid range");
 763         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 764       }
 765 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 766         if (index>=0 && index<(int)self->size()+1)
 767           self->insert(self->begin()+index, x);
 768         else
 769           throw std::out_of_range("index");
 770       }
 771 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 772         if (index>=0 && index<(int)self->size()+1)
 773           self->insert(self->begin()+index, values.begin(), values.end());
 774         else
 775           throw std::out_of_range("index");
 776       }
 777 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 778         if (index>=0 && index<(int)self->size())
 779           self->erase(self->begin() + index);
 780         else
 781           throw std::out_of_range("index");
 782       }
 783 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 784         if (index < 0)
 785           throw std::out_of_range("index");
 786         if (count < 0)
 787           throw std::out_of_range("count");
 788         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 789           throw std::invalid_argument("invalid range");
 790         self->erase(self->begin()+index, self->begin()+index+count);
 791       }
 792 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 793         if (count < 0)
 794           throw std::out_of_range("count");
 795         return new std::vector< Dali::TouchPoint >(count, value);
 796       }
 797 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 798         std::reverse(self->begin(), self->end());
 799       }
 800 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 801         if (index < 0)
 802           throw std::out_of_range("index");
 803         if (count < 0)
 804           throw std::out_of_range("count");
 805         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 806           throw std::invalid_argument("invalid range");
 807         std::reverse(self->begin()+index, self->begin()+index+count);
 808       }
 809 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 810         if (index < 0)
 811           throw std::out_of_range("index");
 812         if (index+values.size() > self->size())
 813           throw std::out_of_range("index");
 814         std::copy(values.begin(), values.end(), self->begin()+index);
 815       }
 816 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 817          return self->Empty();
 818       }
 819 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 820         return self->GetConnectionCount();
 821       }
 822 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 823           self->Connect( func );
 824       }
 825 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 826           self->Disconnect( func );
 827       }
 828 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 829           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 830 /*@SWIG@*/ self->Emit( arg );
 831       }
 832 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 833          return self->Empty();
 834       }
 835 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 836         return self->GetConnectionCount();
 837       }
 838 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 839           self->Connect( func );
 840       }
 841 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 842           self->Disconnect( func );
 843       }
 844 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 845           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 846 /*@SWIG@*/ self->Emit( arg );
 847       }
 848 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 849          return self->Empty();
 850       }
 851 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){
 852         return self->GetConnectionCount();
 853       }
 854 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 *)){
 855           self->Connect( func );
 856       }
 857 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 *)){
 858           self->Disconnect( func );
 859       }
 860 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){
 861           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 862 /*@SWIG@*/ self->Emit( arg );
 863       }
 864 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 865          return self->Empty();
 866       }
 867 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 868         return self->GetConnectionCount();
 869       }
 870 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 871           self->Connect( func );
 872       }
 873 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 874           self->Disconnect( func );
 875       }
 876 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 877           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 878 /*@SWIG@*/ self->Emit( arg );
 879       }
 880 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){
 881          return self->Empty();
 882       }
 883 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){
 884         return self->GetConnectionCount();
 885       }
 886 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 &)){
 887         self->Connect( func );
 888       }
 889 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 &)){
 890         self->Disconnect( func );
 891       }
 892 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){
 893         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 894 /*@SWIG@*/ self->Emit( arg1, arg2 );
 895       }
 896 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 897          return self->Empty();
 898       }
 899 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 900         return self->GetConnectionCount();
 901       }
 902 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 903         self->Connect( func );
 904       }
 905 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 906         self->Disconnect( func );
 907       }
 908 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 909         return self->Emit( arg1, arg2 );
 910       }
 911 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){
 912          return self->Empty();
 913       }
 914 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){
 915         return self->GetConnectionCount();
 916       }
 917 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 &)){
 918         self->Connect( func );
 919       }
 920 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 &)){
 921         self->Disconnect( func );
 922       }
 923 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){
 924         return self->Emit( arg1, arg2 );
 925       }
 926 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){
 927          return self->Empty();
 928       }
 929 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){
 930         return self->GetConnectionCount();
 931       }
 932 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 &)){
 933         self->Connect( func );
 934       }
 935 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 &)){
 936         self->Disconnect( func );
 937       }
 938 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){
 939         return self->Emit( arg1, arg2 );
 940       }
 941 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 942          return self->Empty();
 943       }
 944 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 945         return self->GetConnectionCount();
 946       }
 947 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 948           self->Connect( func );
 949       }
 950 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 951           self->Disconnect( func );
 952       }
 953 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 954           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 955 /*@SWIG@*/ self->Emit( arg );
 956       }
 957 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 958          return self->Empty();
 959       }
 960 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){
 961         return self->GetConnectionCount();
 962       }
 963 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 &)){
 964           self->Connect( func );
 965       }
 966 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 &)){
 967           self->Disconnect( func );
 968       }
 969 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){
 970           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 971 /*@SWIG@*/ self->Emit( arg );
 972       }
 973 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 974          return self->Empty();
 975       }
 976 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 977         return self->GetConnectionCount();
 978       }
 979 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 980           self->Connect( func );
 981       }
 982 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 983           self->Disconnect( func );
 984       }
 985 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 986           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 987 /*@SWIG@*/ self->Emit( arg );
 988       }
 989 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 990          return self->Empty();
 991       }
 992 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){
 993         return self->GetConnectionCount();
 994       }
 995 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 &)){
 996           self->Connect( func );
 997       }
 998 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 &)){
 999           self->Disconnect( func );
1000       }
1001 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){
1002           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1003 /*@SWIG@*/ self->Emit( arg );
1004       }
1005 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){
1006          return self->Empty();
1007       }
1008 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){
1009         return self->GetConnectionCount();
1010       }
1011 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 &)){
1012         self->Connect( func );
1013       }
1014 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 &)){
1015         self->Disconnect( func );
1016       }
1017 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){
1018         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1019 /*@SWIG@*/ self->Emit( arg1, arg2 );
1020       }
1021 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){
1022          return self->Empty();
1023       }
1024 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){
1025         return self->GetConnectionCount();
1026       }
1027 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 &)){
1028         self->Connect( func );
1029       }
1030 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 &)){
1031         self->Disconnect( func );
1032       }
1033 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){
1034         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1035 /*@SWIG@*/ self->Emit( arg1, arg2 );
1036       }
1037 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){
1038          return self->Empty();
1039       }
1040 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){
1041         return self->GetConnectionCount();
1042       }
1043 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 &)){
1044         self->Connect( func );
1045       }
1046 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 &)){
1047         self->Disconnect( func );
1048       }
1049 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){
1050         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1051 /*@SWIG@*/ self->Emit( arg1, arg2 );
1052       }
1053 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){
1054          return self->Empty();
1055       }
1056 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){
1057         return self->GetConnectionCount();
1058       }
1059 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)){
1060           return self->Connect( func );
1061       }
1062 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)){
1063           self->Disconnect( func );
1064       }
1065 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){
1066           self->Emit( arg1, arg3 );
1067       }
1068 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){
1069          return self->Empty();
1070       }
1071 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){
1072         return self->GetConnectionCount();
1073       }
1074 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)){
1075           return self->Connect( func );
1076       }
1077 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)){
1078           self->Disconnect( func );
1079       }
1080 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){
1081           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1082 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1083       }
1084
1085 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1086          return self->Empty();
1087       }
1088 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1089         return self->GetConnectionCount();
1090       }
1091 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1092           self->Connect( func );
1093       }
1094 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1095           self->Disconnect( func );
1096       }
1097 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1098           return self->Emit();
1099       }
1100
1101 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1102         std::vector< unsigned int >* pv = 0;
1103         if (capacity >= 0) {
1104           pv = new std::vector< unsigned int >();
1105           pv->reserve(capacity);
1106        } else {
1107           throw std::out_of_range("capacity");
1108        }
1109        return pv;
1110       }
1111 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1112         if (index>=0 && index<(int)self->size())
1113           return (*self)[index];
1114         else
1115           throw std::out_of_range("index");
1116       }
1117 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1118         if (index>=0 && index<(int)self->size())
1119           return (*self)[index];
1120         else
1121           throw std::out_of_range("index");
1122       }
1123 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1124         if (index>=0 && index<(int)self->size())
1125           (*self)[index] = val;
1126         else
1127           throw std::out_of_range("index");
1128       }
1129 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1130         self->insert(self->end(), values.begin(), values.end());
1131       }
1132 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1133         if (index < 0)
1134           throw std::out_of_range("index");
1135         if (count < 0)
1136           throw std::out_of_range("count");
1137         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1138           throw std::invalid_argument("invalid range");
1139         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1140       }
1141 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1142         if (index>=0 && index<(int)self->size()+1)
1143           self->insert(self->begin()+index, x);
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1148         if (index>=0 && index<(int)self->size()+1)
1149           self->insert(self->begin()+index, values.begin(), values.end());
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1154         if (index>=0 && index<(int)self->size())
1155           self->erase(self->begin() + index);
1156         else
1157           throw std::out_of_range("index");
1158       }
1159 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1160         if (index < 0)
1161           throw std::out_of_range("index");
1162         if (count < 0)
1163           throw std::out_of_range("count");
1164         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1165           throw std::invalid_argument("invalid range");
1166         self->erase(self->begin()+index, self->begin()+index+count);
1167       }
1168 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1169         if (count < 0)
1170           throw std::out_of_range("count");
1171         return new std::vector< unsigned int >(count, value);
1172       }
1173 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1174         std::reverse(self->begin(), self->end());
1175       }
1176 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1177         if (index < 0)
1178           throw std::out_of_range("index");
1179         if (count < 0)
1180           throw std::out_of_range("count");
1181         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1182           throw std::invalid_argument("invalid range");
1183         std::reverse(self->begin()+index, self->begin()+index+count);
1184       }
1185 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1186         if (index < 0)
1187           throw std::out_of_range("index");
1188         if (index+values.size() > self->size())
1189           throw std::out_of_range("index");
1190         std::copy(values.begin(), values.end(), self->begin()+index);
1191       }
1192 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1193         return std::find(self->begin(), self->end(), value) != self->end();
1194       }
1195 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1196         int index = -1;
1197         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1198         if (it != self->end())
1199           index = (int)(it - self->begin());
1200         return index;
1201       }
1202 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1203         int index = -1;
1204         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1205         if (rit != self->rend())
1206           index = (int)(self->rend() - 1 - rit);
1207         return index;
1208       }
1209 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1210         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1211         if (it != self->end()) {
1212           self->erase(it);
1213           return true;
1214         }
1215         return false;
1216       }
1217 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){
1218         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1219         if (capacity >= 0) {
1220           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1221           pv->reserve(capacity);
1222        } else {
1223           throw std::out_of_range("capacity");
1224        }
1225        return pv;
1226       }
1227 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){
1228         if (index>=0 && index<(int)self->size())
1229           return (*self)[index];
1230         else
1231           throw std::out_of_range("index");
1232       }
1233 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){
1234         if (index>=0 && index<(int)self->size())
1235           return (*self)[index];
1236         else
1237           throw std::out_of_range("index");
1238       }
1239 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){
1240         if (index>=0 && index<(int)self->size())
1241           (*self)[index] = val;
1242         else
1243           throw std::out_of_range("index");
1244       }
1245 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1246         self->insert(self->end(), values.begin(), values.end());
1247       }
1248 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){
1249         if (index < 0)
1250           throw std::out_of_range("index");
1251         if (count < 0)
1252           throw std::out_of_range("count");
1253         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1254           throw std::invalid_argument("invalid range");
1255         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1256       }
1257 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){
1258         if (index>=0 && index<(int)self->size()+1)
1259           self->insert(self->begin()+index, x);
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 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){
1264         if (index>=0 && index<(int)self->size()+1)
1265           self->insert(self->begin()+index, values.begin(), values.end());
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1270         if (index>=0 && index<(int)self->size())
1271           self->erase(self->begin() + index);
1272         else
1273           throw std::out_of_range("index");
1274       }
1275 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1276         if (index < 0)
1277           throw std::out_of_range("index");
1278         if (count < 0)
1279           throw std::out_of_range("count");
1280         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1281           throw std::invalid_argument("invalid range");
1282         self->erase(self->begin()+index, self->begin()+index+count);
1283       }
1284 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){
1285         if (count < 0)
1286           throw std::out_of_range("count");
1287         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1288       }
1289 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){
1290         std::reverse(self->begin(), self->end());
1291       }
1292 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){
1293         if (index < 0)
1294           throw std::out_of_range("index");
1295         if (count < 0)
1296           throw std::out_of_range("count");
1297         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1298           throw std::invalid_argument("invalid range");
1299         std::reverse(self->begin()+index, self->begin()+index+count);
1300       }
1301 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){
1302         if (index < 0)
1303           throw std::out_of_range("index");
1304         if (index+values.size() > self->size())
1305           throw std::out_of_range("index");
1306         std::copy(values.begin(), values.end(), self->begin()+index);
1307       }
1308 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1309         std::vector< Dali::Actor >* pv = 0;
1310         if (capacity >= 0) {
1311           pv = new std::vector< Dali::Actor >();
1312           pv->reserve(capacity);
1313        } else {
1314           throw std::out_of_range("capacity");
1315        }
1316        return pv;
1317       }
1318 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1319         if (index>=0 && index<(int)self->size())
1320           return (*self)[index];
1321         else
1322           throw std::out_of_range("index");
1323       }
1324 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1325         if (index>=0 && index<(int)self->size())
1326           return (*self)[index];
1327         else
1328           throw std::out_of_range("index");
1329       }
1330 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1331         if (index>=0 && index<(int)self->size())
1332           (*self)[index] = val;
1333         else
1334           throw std::out_of_range("index");
1335       }
1336 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1337         self->insert(self->end(), values.begin(), values.end());
1338       }
1339 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1340         if (index < 0)
1341           throw std::out_of_range("index");
1342         if (count < 0)
1343           throw std::out_of_range("count");
1344         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1345           throw std::invalid_argument("invalid range");
1346         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1347       }
1348 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1349         if (index>=0 && index<(int)self->size()+1)
1350           self->insert(self->begin()+index, x);
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1355         if (index>=0 && index<(int)self->size()+1)
1356           self->insert(self->begin()+index, values.begin(), values.end());
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1361         if (index>=0 && index<(int)self->size())
1362           self->erase(self->begin() + index);
1363         else
1364           throw std::out_of_range("index");
1365       }
1366 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1367         if (index < 0)
1368           throw std::out_of_range("index");
1369         if (count < 0)
1370           throw std::out_of_range("count");
1371         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1372           throw std::invalid_argument("invalid range");
1373         self->erase(self->begin()+index, self->begin()+index+count);
1374       }
1375 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1376         if (count < 0)
1377           throw std::out_of_range("count");
1378         return new std::vector< Dali::Actor >(count, value);
1379       }
1380 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1381         std::reverse(self->begin(), self->end());
1382       }
1383 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1384         if (index < 0)
1385           throw std::out_of_range("index");
1386         if (count < 0)
1387           throw std::out_of_range("count");
1388         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1389           throw std::invalid_argument("invalid range");
1390         std::reverse(self->begin()+index, self->begin()+index+count);
1391       }
1392 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1393         if (index < 0)
1394           throw std::out_of_range("index");
1395         if (index+values.size() > self->size())
1396           throw std::out_of_range("index");
1397         std::copy(values.begin(), values.end(), self->begin()+index);
1398       }
1399 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1400          return self->Empty();
1401       }
1402 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1403         return self->GetConnectionCount();
1404       }
1405 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 &)){
1406           self->Connect( func );
1407       }
1408 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 &)){
1409           self->Disconnect( func );
1410       }
1411 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){
1412           return self->Emit( arg );
1413       }
1414 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){
1415          return self->Empty();
1416       }
1417 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){
1418         return self->GetConnectionCount();
1419       }
1420 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)){
1421         self->Connect( func );
1422       }
1423 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)){
1424         self->Disconnect( func );
1425       }
1426 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){
1427         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1428 /*@SWIG@*/ self->Emit( arg1, arg2 );
1429       }
1430 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1431          return self->Empty();
1432       }
1433 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){
1434         return self->GetConnectionCount();
1435       }
1436 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)){
1437         self->Connect( func );
1438       }
1439 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)){
1440         self->Disconnect( func );
1441       }
1442 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){
1443         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1444 /*@SWIG@*/ self->Emit( arg1, arg2 );
1445       }
1446 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1447          return self->Empty();
1448       }
1449 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1450         return self->GetConnectionCount();
1451       }
1452 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)){
1453         self->Connect( func );
1454       }
1455 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)){
1456         self->Disconnect( func );
1457       }
1458 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){
1459         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1460 /*@SWIG@*/ self->Emit( arg1, arg2 );
1461       }
1462 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){
1463          return self->Empty();
1464       }
1465 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){
1466         return self->GetConnectionCount();
1467       }
1468 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)){
1469         self->Connect( func );
1470       }
1471 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)){
1472         self->Disconnect( func );
1473       }
1474 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){
1475         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1476 /*@SWIG@*/ self->Emit( arg1, arg2 );
1477       }
1478 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1479          return self->Empty();
1480       }
1481 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1482         return self->GetConnectionCount();
1483       }
1484 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)){
1485           self->Connect( func );
1486       }
1487 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)){
1488           self->Disconnect( func );
1489       }
1490 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1491           return self->Emit( arg );
1492       }
1493 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1494          return self->Empty();
1495       }
1496 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1497         return self->GetConnectionCount();
1498       }
1499 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)){
1500           self->Connect( func );
1501       }
1502 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)){
1503           self->Disconnect( func );
1504       }
1505 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1506           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1507 /*@SWIG@*/ self->Emit( arg );
1508       }
1509 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){
1510          return self->Empty();
1511       }
1512 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){
1513         return self->GetConnectionCount();
1514       }
1515 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)){
1516           return self->Connect( func );
1517       }
1518 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)){
1519           self->Disconnect( func );
1520       }
1521 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){
1522           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1523 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1524       }
1525 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1526          return self->Empty();
1527       }
1528 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1529         return self->GetConnectionCount();
1530       }
1531 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)){
1532           self->Connect( func );
1533       }
1534 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)){
1535           self->Disconnect( func );
1536       }
1537 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1538           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1539 /*@SWIG@*/ self->Emit( arg );
1540       }
1541 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){
1542          return self->Empty();
1543       }
1544 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){
1545         return self->GetConnectionCount();
1546       }
1547 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)){
1548           return self->Connect( func );
1549       }
1550 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)){
1551           self->Disconnect( func );
1552       }
1553 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){
1554           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1555 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1556       }
1557 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){
1558          return self->Empty();
1559       }
1560 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){
1561         return self->GetConnectionCount();
1562       }
1563 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 &)){
1564           self->Connect( func );
1565       }
1566 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 &)){
1567           self->Disconnect( func );
1568       }
1569 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){
1570           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1571 /*@SWIG@*/ self->Emit( arg );
1572       }
1573 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1574          return self->Empty();
1575       }
1576 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){
1577         return self->GetConnectionCount();
1578       }
1579 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 &)){
1580           self->Connect( func );
1581       }
1582 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 &)){
1583           self->Disconnect( func );
1584       }
1585 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){
1586           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1587 /*@SWIG@*/ self->Emit( arg );
1588       }
1589
1590
1591 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){
1592          return self->Empty();
1593       }
1594 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){
1595         return self->GetConnectionCount();
1596       }
1597 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 &)){
1598         self->Connect( func );
1599       }
1600 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 &)){
1601         self->Disconnect( func );
1602       }
1603 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){
1604         return self->Emit( arg1, arg2 );
1605       }
1606 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1607          return self->Empty();
1608       }
1609 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1610         return self->GetConnectionCount();
1611       }
1612 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)){
1613           self->Connect( func );
1614       }
1615 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)){
1616           self->Disconnect( func );
1617       }
1618 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1619           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1620 /*@SWIG@*/ self->Emit( arg );
1621       }
1622 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1623          return self->Empty();
1624       }
1625 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1626         return self->GetConnectionCount();
1627       }
1628 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 &)){
1629           self->Connect( func );
1630       }
1631 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 &)){
1632           self->Disconnect( func );
1633       }
1634 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){
1635           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1636 /*@SWIG@*/ self->Emit( arg );
1637       }
1638 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1639          return self->Empty();
1640       }
1641 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){
1642         return self->GetConnectionCount();
1643       }
1644 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)){
1645         self->Connect( func );
1646       }
1647 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)){
1648         self->Disconnect( func );
1649       }
1650 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){
1651         return self->Emit( arg1, arg2 );
1652       }
1653 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1654          return self->Empty();
1655       }
1656 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){
1657         return self->GetConnectionCount();
1658       }
1659 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)){
1660         self->Connect( func );
1661       }
1662 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)){
1663         self->Disconnect( func );
1664       }
1665 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){
1666         return self->Emit( arg1, arg2 );
1667       }
1668
1669 /* ---------------------------------------------------
1670  * C++ director class methods
1671  * --------------------------------------------------- */
1672
1673 #include "dali_wrap.h"
1674
1675 /*
1676  *  Widget director
1677  */
1678 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1679   swig_init_callbacks();
1680 }
1681
1682 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1683 }
1684
1685 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1686   char * jcontentInfo = 0 ;
1687   void * jwindow  ;
1688
1689   if (!swig_callbackOnCreate) {
1690     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1691     return;
1692   } else {
1693     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1694     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1695     swig_callbackOnCreate(jcontentInfo, jwindow);
1696   }
1697 }
1698
1699 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1700   char * jcontentInfo = 0 ;
1701   int jtype  ;
1702
1703   if (!swig_callbackOnTerminate) {
1704     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1705     return;
1706   } else {
1707     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1708     jtype = (int)type;
1709     swig_callbackOnTerminate(jcontentInfo, jtype);
1710   }
1711 }
1712
1713 void SwigDirector_WidgetImpl::OnPause() {
1714   if (!swig_callbackOnPause) {
1715     Dali::Internal::Adaptor::Widget::OnPause();
1716     return;
1717   } else {
1718     swig_callbackOnPause();
1719   }
1720 }
1721
1722 void SwigDirector_WidgetImpl::OnResume() {
1723   if (!swig_callbackOnResume) {
1724     Dali::Internal::Adaptor::Widget::OnResume();
1725     return;
1726   } else {
1727     swig_callbackOnResume();
1728   }
1729 }
1730
1731 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1732   void * jwindow  ;
1733
1734   if (!swig_callbackOnResize) {
1735     Dali::Internal::Adaptor::Widget::OnResize(window);
1736     return;
1737   } else {
1738     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1739     swig_callbackOnResize(jwindow);
1740   }
1741 }
1742
1743 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1744   char * jcontentInfo = 0 ;
1745   int jforce  ;
1746
1747   if (!swig_callbackOnUpdate) {
1748     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1749     return;
1750   } else {
1751     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1752     jforce = force;
1753     swig_callbackOnUpdate(jcontentInfo, jforce);
1754   }
1755 }
1756
1757 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1758   void * jslotObserver = 0 ;
1759   void * jcallback = 0 ;
1760
1761   if (!swig_callbackSignalConnected) {
1762     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1763     return;
1764   } else {
1765     jslotObserver = (void *) slotObserver;
1766     jcallback = (void *) callback;
1767     swig_callbackSignalConnected(jslotObserver, jcallback);
1768   }
1769 }
1770
1771 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1772   void * jslotObserver = 0 ;
1773   void * jcallback = 0 ;
1774
1775   if (!swig_callbackSignalDisconnected) {
1776     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1777     return;
1778   } else {
1779     jslotObserver = (void *) slotObserver;
1780     jcallback = (void *) callback;
1781     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1782   }
1783 }
1784
1785 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) {
1786
1787   swig_callbackOnCreate = callbackOnCreate;
1788   swig_callbackOnTerminate = callbackOnTerminate;
1789   swig_callbackOnPause = callbackOnPause;
1790   swig_callbackOnResume = callbackOnResume;
1791   swig_callbackOnResize = callbackOnResize;
1792   swig_callbackOnUpdate = callbackOnUpdate;
1793   swig_callbackSignalConnected = callbackSignalConnected;
1794   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1795 }
1796
1797 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1798   swig_callbackOnCreate = 0;
1799   swig_callbackOnTerminate = 0;
1800   swig_callbackOnPause = 0;
1801   swig_callbackOnResume = 0;
1802   swig_callbackOnResize = 0;
1803   swig_callbackOnUpdate = 0;
1804   swig_callbackSignalConnected = 0;
1805   swig_callbackSignalDisconnected = 0;
1806 }
1807
1808
1809 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1810   swig_init_callbacks();
1811 }
1812
1813 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1814
1815 }
1816
1817
1818 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1819   int jdepth  ;
1820
1821   if (!swig_callbackOnStageConnection) {
1822     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1823     return;
1824   } else {
1825     jdepth = depth;
1826     swig_callbackOnStageConnection(jdepth);
1827   }
1828 }
1829
1830 void SwigDirector_ViewImpl::OnStageDisconnection() {
1831   if (!swig_callbackOnStageDisconnection) {
1832     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1833     return;
1834   } else {
1835     swig_callbackOnStageDisconnection();
1836   }
1837 }
1838
1839 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1840   void * jchild = 0 ;
1841
1842   if (!swig_callbackOnChildAdd) {
1843     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1844     return;
1845   } else {
1846     jchild = (Dali::Actor *) &child;
1847     swig_callbackOnChildAdd(jchild);
1848   }
1849 }
1850
1851 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1852   void * jchild = 0 ;
1853
1854   if (!swig_callbackOnChildRemove) {
1855     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1856     return;
1857   } else {
1858     jchild = (Dali::Actor *) &child;
1859     swig_callbackOnChildRemove(jchild);
1860   }
1861 }
1862
1863 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1864   int jindex  ;
1865   void * jpropertyValue  ;
1866
1867   if (!swig_callbackOnPropertySet) {
1868     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1869     return;
1870   } else {
1871     jindex = index;
1872     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1873     swig_callbackOnPropertySet(jindex, jpropertyValue);
1874   }
1875 }
1876
1877 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1878   void * jtargetSize = 0 ;
1879
1880   if (!swig_callbackOnSizeSet) {
1881     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1882     return;
1883   } else {
1884     jtargetSize = (Dali::Vector3 *) &targetSize;
1885     swig_callbackOnSizeSet(jtargetSize);
1886   }
1887 }
1888
1889 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1890   void * janimation = 0 ;
1891   void * jtargetSize = 0 ;
1892
1893   if (!swig_callbackOnSizeAnimation) {
1894     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1895     return;
1896   } else {
1897     janimation = (Dali::Animation *) &animation;
1898     jtargetSize = (Dali::Vector3 *) &targetSize;
1899     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1900   }
1901 }
1902
1903 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1904   bool c_result = SwigValueInit< bool >() ;
1905   unsigned int jresult = 0 ;
1906   void * jarg0 = 0 ;
1907
1908   if (!swig_callbackOnTouchEvent) {
1909     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1910   } else {
1911     jarg0 = (Dali::TouchEvent *) &event;
1912     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1913     c_result = jresult ? true : false;
1914   }
1915   return c_result;
1916 }
1917
1918 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1919   bool c_result = SwigValueInit< bool >() ;
1920   unsigned int jresult = 0 ;
1921   void * jarg0 = 0 ;
1922
1923   if (!swig_callbackOnHoverEvent) {
1924     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1925   } else {
1926     jarg0 = (Dali::HoverEvent *) &event;
1927     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1928     c_result = jresult ? true : false;
1929   }
1930   return c_result;
1931 }
1932
1933 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1934   bool c_result = SwigValueInit< bool >() ;
1935   unsigned int jresult = 0 ;
1936   void * jarg0 = 0 ;
1937
1938   if (!swig_callbackOnKeyEvent) {
1939     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1940   } else {
1941     jarg0 = (Dali::KeyEvent *) &event;
1942     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1943     c_result = jresult ? true : false;
1944   }
1945   return c_result;
1946 }
1947
1948 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1949   bool c_result = SwigValueInit< bool >() ;
1950   unsigned int jresult = 0 ;
1951   void * jarg0 = 0 ;
1952
1953   if (!swig_callbackOnWheelEvent) {
1954     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1955   } else {
1956     jarg0 = (Dali::WheelEvent *) &event;
1957     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1958     c_result = jresult ? true : false;
1959   }
1960   return c_result;
1961 }
1962
1963 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1964   void * jsize = 0 ;
1965   void * jcontainer = 0 ;
1966
1967   if (!swig_callbackOnRelayout) {
1968     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1969     return;
1970   } else {
1971     jsize = (Dali::Vector2 *) &size;
1972     jcontainer = (Dali::RelayoutContainer *) &container;
1973     swig_callbackOnRelayout(jsize, jcontainer);
1974   }
1975 }
1976
1977 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1978   int jpolicy  ;
1979   int jdimension  ;
1980
1981   if (!swig_callbackOnSetResizePolicy) {
1982     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1983     return;
1984   } else {
1985     jpolicy = (int)policy;
1986     jdimension = (int)dimension;
1987     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1988   }
1989 }
1990
1991 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1992   Dali::Vector3 c_result ;
1993   void * jresult = 0 ;
1994
1995   if (!swig_callbackGetNaturalSize) {
1996     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1997   } else {
1998     jresult = (void *) swig_callbackGetNaturalSize();
1999     if (!jresult) {
2000       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2001       return c_result;
2002     }
2003     c_result = *(Dali::Vector3 *)jresult;
2004   }
2005   return c_result;
2006 }
2007
2008 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2009   float c_result = SwigValueInit< float >() ;
2010   float jresult = 0 ;
2011   void * jchild = 0 ;
2012   int jdimension  ;
2013
2014   if (!swig_callbackCalculateChildSize) {
2015     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2016   } else {
2017     jchild = (Dali::Actor *) &child;
2018     jdimension = (int)dimension;
2019     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2020     c_result = (float)jresult;
2021   }
2022   return c_result;
2023 }
2024
2025 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2026   float c_result = SwigValueInit< float >() ;
2027   float jresult = 0 ;
2028   float jwidth  ;
2029
2030   if (!swig_callbackGetHeightForWidth) {
2031     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2032   } else {
2033     jwidth = width;
2034     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2035     c_result = (float)jresult;
2036   }
2037   return c_result;
2038 }
2039
2040 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2041   float c_result = SwigValueInit< float >() ;
2042   float jresult = 0 ;
2043   float jheight  ;
2044
2045   if (!swig_callbackGetWidthForHeight) {
2046     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2047   } else {
2048     jheight = height;
2049     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2050     c_result = (float)jresult;
2051   }
2052   return c_result;
2053 }
2054
2055 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2056   bool c_result = SwigValueInit< bool >() ;
2057   unsigned int jresult = 0 ;
2058   int jdimension  ;
2059
2060   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2061     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2062   } else {
2063     jdimension = (int)dimension;
2064     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2065     c_result = jresult ? true : false;
2066   }
2067   return c_result;
2068 }
2069
2070 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2071   int jdimension  ;
2072
2073   if (!swig_callbackOnCalculateRelayoutSize) {
2074     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2075     return;
2076   } else {
2077     jdimension = (int)dimension;
2078     swig_callbackOnCalculateRelayoutSize(jdimension);
2079   }
2080 }
2081
2082 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2083   float jsize  ;
2084   int jdimension  ;
2085
2086   if (!swig_callbackOnLayoutNegotiated) {
2087     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2088     return;
2089   } else {
2090     jsize = size;
2091     jdimension = (int)dimension;
2092     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2093   }
2094 }
2095
2096 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2097   return Dali::CustomActorImpl::GetExtension();
2098 }
2099
2100 void SwigDirector_ViewImpl::OnInitialize() {
2101   if (!swig_callbackOnInitialize) {
2102     Dali::Toolkit::Internal::Control::OnInitialize();
2103     return;
2104   } else {
2105     swig_callbackOnInitialize();
2106   }
2107 }
2108
2109 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2110   void * jchild = 0 ;
2111
2112   if (!swig_callbackOnControlChildAdd) {
2113     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2114     return;
2115   } else {
2116     jchild = (Dali::Actor *) &child;
2117     swig_callbackOnControlChildAdd(jchild);
2118   }
2119 }
2120
2121 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2122   void * jchild = 0 ;
2123
2124   if (!swig_callbackOnControlChildRemove) {
2125     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2126     return;
2127   } else {
2128     jchild = (Dali::Actor *) &child;
2129     swig_callbackOnControlChildRemove(jchild);
2130   }
2131 }
2132
2133 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2134   void * jstyleManager  ;
2135   int jchange  ;
2136
2137   if (!swig_callbackOnStyleChange) {
2138     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2139     return;
2140   } else {
2141     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2142     jchange = (int)change;
2143     swig_callbackOnStyleChange(jstyleManager, jchange);
2144   }
2145 }
2146
2147 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2148   bool c_result = SwigValueInit< bool >() ;
2149   unsigned int jresult = 0 ;
2150
2151   if (!swig_callbackOnAccessibilityActivated) {
2152     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2153   } else {
2154     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2155     c_result = jresult ? true : false;
2156   }
2157   return c_result;
2158 }
2159
2160 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2161   bool c_result = SwigValueInit< bool >() ;
2162   unsigned int jresult = 0 ;
2163   void * jgesture  ;
2164
2165   if (!swig_callbackOnAccessibilityPan) {
2166     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2167   } else {
2168     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2169     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2170     c_result = jresult ? true : false;
2171   }
2172   return c_result;
2173 }
2174
2175 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2176   bool c_result = SwigValueInit< bool >() ;
2177   unsigned int jresult = 0 ;
2178   void * jtouchEvent = 0 ;
2179
2180   if (!swig_callbackOnAccessibilityTouch) {
2181     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2182   } else {
2183     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2184     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2185     c_result = jresult ? true : false;
2186   }
2187   return c_result;
2188 }
2189
2190 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2191   bool c_result = SwigValueInit< bool >() ;
2192   unsigned int jresult = 0 ;
2193   unsigned int jisIncrease  ;
2194
2195   if (!swig_callbackOnAccessibilityValueChange) {
2196     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2197   } else {
2198     jisIncrease = isIncrease;
2199     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2200     c_result = jresult ? true : false;
2201   }
2202   return c_result;
2203 }
2204
2205 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2206   bool c_result = SwigValueInit< bool >() ;
2207   unsigned int jresult = 0 ;
2208
2209   if (!swig_callbackOnAccessibilityZoom) {
2210     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2211   } else {
2212     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2213     c_result = jresult ? true : false;
2214   }
2215   return c_result;
2216 }
2217
2218 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2219   if (!swig_callbackOnKeyInputFocusGained) {
2220     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2221     return;
2222   } else {
2223     swig_callbackOnKeyInputFocusGained();
2224   }
2225 }
2226
2227 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2228   if (!swig_callbackOnKeyInputFocusLost) {
2229     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2230     return;
2231   } else {
2232     swig_callbackOnKeyInputFocusLost();
2233   }
2234 }
2235
2236 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2237   Dali::Actor c_result ;
2238   void * jresult = 0 ;
2239   void * jcurrentFocusedActor  ;
2240   int jdirection  ;
2241   unsigned int jloopEnabled  ;
2242
2243   if (!swig_callbackGetNextKeyboardFocusableActor) {
2244     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2245   } else {
2246     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2247     jdirection = (int)direction;
2248     jloopEnabled = loopEnabled;
2249     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2250     if (!jresult) {
2251       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2252       return c_result;
2253     }
2254     c_result = *(Dali::Actor *)jresult;
2255   }
2256   return c_result;
2257 }
2258
2259 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2260   void * jcommitedFocusableActor  ;
2261
2262   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2263     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2264     return;
2265   } else {
2266     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2267     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2268   }
2269 }
2270
2271 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2272   bool c_result = SwigValueInit< bool >() ;
2273   unsigned int jresult = 0 ;
2274
2275   if (!swig_callbackOnKeyboardEnter) {
2276     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2277   } else {
2278     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2279     c_result = jresult ? true : false;
2280   }
2281   return c_result;
2282 }
2283
2284 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2285   void * jpinch = 0 ;
2286
2287   if (!swig_callbackOnPinch) {
2288     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2289     return;
2290   } else {
2291     jpinch = (Dali::PinchGesture *) &pinch;
2292     swig_callbackOnPinch(jpinch);
2293   }
2294 }
2295
2296 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2297   void * jpan = 0 ;
2298
2299   if (!swig_callbackOnPan) {
2300     Dali::Toolkit::Internal::Control::OnPan(pan);
2301     return;
2302   } else {
2303     jpan = (Dali::PanGesture *) &pan;
2304     swig_callbackOnPan(jpan);
2305   }
2306 }
2307
2308 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2309   void * jtap = 0 ;
2310
2311   if (!swig_callbackOnTap) {
2312     Dali::Toolkit::Internal::Control::OnTap(tap);
2313     return;
2314   } else {
2315     jtap = (Dali::TapGesture *) &tap;
2316     swig_callbackOnTap(jtap);
2317   }
2318 }
2319
2320 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2321   void * jlongPress = 0 ;
2322
2323   if (!swig_callbackOnLongPress) {
2324     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2325     return;
2326   } else {
2327     jlongPress = (Dali::LongPressGesture *) &longPress;
2328     swig_callbackOnLongPress(jlongPress);
2329   }
2330 }
2331
2332 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2333   void * jslotObserver = 0 ;
2334   void * jcallback = 0 ;
2335
2336   if (!swig_callbackSignalConnected) {
2337     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2338     return;
2339   } else {
2340     jslotObserver = (void *) slotObserver;
2341     jcallback = (void *) callback;
2342     swig_callbackSignalConnected(jslotObserver, jcallback);
2343   }
2344 }
2345
2346 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2347   void * jslotObserver = 0 ;
2348   void * jcallback = 0 ;
2349
2350   if (!swig_callbackSignalDisconnected) {
2351     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2352     return;
2353   } else {
2354     jslotObserver = (void *) slotObserver;
2355     jcallback = (void *) callback;
2356     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2357   }
2358 }
2359
2360 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2361   return Dali::Toolkit::Internal::Control::GetControlExtension();
2362 }
2363
2364 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, 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_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2365   swig_callbackOnStageConnection = callbackOnStageConnection;
2366   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2367   swig_callbackOnChildAdd = callbackOnChildAdd;
2368   swig_callbackOnChildRemove = callbackOnChildRemove;
2369   swig_callbackOnPropertySet = callbackOnPropertySet;
2370   swig_callbackOnSizeSet = callbackOnSizeSet;
2371   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2372   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2373   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2374   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2375   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2376   swig_callbackOnRelayout = callbackOnRelayout;
2377   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2378   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2379   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2380   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2381   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2382   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2383   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2384   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2385   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2386   swig_callbackOnInitialize = callbackOnInitialize;
2387   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2388   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2389   swig_callbackOnStyleChange = callbackOnStyleChange;
2390   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2391   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2392   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2393   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2394   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2395   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2396   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2397   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2398   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2399   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2400   swig_callbackOnPinch = callbackOnPinch;
2401   swig_callbackOnPan = callbackOnPan;
2402   swig_callbackOnTap = callbackOnTap;
2403   swig_callbackOnLongPress = callbackOnLongPress;
2404   swig_callbackSignalConnected = callbackSignalConnected;
2405   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2406 }
2407
2408 void SwigDirector_ViewImpl::swig_init_callbacks() {
2409   swig_callbackOnStageConnection = 0;
2410   swig_callbackOnStageDisconnection = 0;
2411   swig_callbackOnChildAdd = 0;
2412   swig_callbackOnChildRemove = 0;
2413   swig_callbackOnPropertySet = 0;
2414   swig_callbackOnSizeSet = 0;
2415   swig_callbackOnSizeAnimation = 0;
2416   swig_callbackOnTouchEvent = 0;
2417   swig_callbackOnHoverEvent = 0;
2418   swig_callbackOnKeyEvent = 0;
2419   swig_callbackOnWheelEvent = 0;
2420   swig_callbackOnRelayout = 0;
2421   swig_callbackOnSetResizePolicy = 0;
2422   swig_callbackGetNaturalSize = 0;
2423   swig_callbackCalculateChildSize = 0;
2424   swig_callbackGetHeightForWidth = 0;
2425   swig_callbackGetWidthForHeight = 0;
2426   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2427   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2428   swig_callbackOnCalculateRelayoutSize = 0;
2429   swig_callbackOnLayoutNegotiated = 0;
2430   swig_callbackOnInitialize = 0;
2431   swig_callbackOnControlChildAdd = 0;
2432   swig_callbackOnControlChildRemove = 0;
2433   swig_callbackOnStyleChange = 0;
2434   swig_callbackOnAccessibilityActivated = 0;
2435   swig_callbackOnAccessibilityPan = 0;
2436   swig_callbackOnAccessibilityTouch = 0;
2437   swig_callbackOnAccessibilityValueChange = 0;
2438   swig_callbackOnAccessibilityZoom = 0;
2439   swig_callbackOnKeyInputFocusGained = 0;
2440   swig_callbackOnKeyInputFocusLost = 0;
2441   swig_callbackGetNextKeyboardFocusableActor = 0;
2442   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2443   swig_callbackOnKeyboardEnter = 0;
2444   swig_callbackOnPinch = 0;
2445   swig_callbackOnPan = 0;
2446   swig_callbackOnTap = 0;
2447   swig_callbackOnLongPress = 0;
2448   swig_callbackSignalConnected = 0;
2449   swig_callbackSignalDisconnected = 0;
2450 }
2451
2452 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2453   swig_init_callbacks();
2454 }
2455
2456 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2457
2458 }
2459
2460
2461 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2462   unsigned int c_result = SwigValueInit< unsigned int >() ;
2463   unsigned int jresult = 0 ;
2464
2465   if (!swig_callbackGetNumberOfItems) {
2466     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2467   } else {
2468     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2469     c_result = (unsigned int)jresult;
2470   }
2471   return c_result;
2472 }
2473
2474 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2475   Dali::Actor c_result ;
2476   void * jresult = 0 ;
2477   unsigned int jitemId  ;
2478
2479   if (!swig_callbackNewItem) {
2480     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2481   } else {
2482     jitemId = itemId;
2483     jresult = (void *) swig_callbackNewItem(jitemId);
2484     if (!jresult) {
2485       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2486       return c_result;
2487     }
2488     c_result = *(Dali::Actor *)jresult;
2489   }
2490   return c_result;
2491 }
2492
2493 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2494   unsigned int jitemId  ;
2495   void * jactor  ;
2496
2497   if (!swig_callbackItemReleased) {
2498     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2499     return;
2500   } else {
2501     jitemId = itemId;
2502     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2503     swig_callbackItemReleased(jitemId, jactor);
2504   }
2505 }
2506
2507 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2508   return Dali::Toolkit::ItemFactory::GetExtension();
2509 }
2510
2511 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2512   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2513   swig_callbackNewItem = callbackNewItem;
2514   swig_callbackItemReleased = callbackItemReleased;
2515 }
2516
2517 void SwigDirector_ItemFactory::swig_init_callbacks() {
2518   swig_callbackGetNumberOfItems = 0;
2519   swig_callbackNewItem = 0;
2520   swig_callbackItemReleased = 0;
2521 }
2522
2523 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2524   swig_init_callbacks();
2525 }
2526
2527 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2528
2529 }
2530
2531
2532 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2533   Dali::Actor c_result ;
2534   void * jresult = 0 ;
2535   void * jcurrent  ;
2536   void * jproposed  ;
2537   int jdirection  ;
2538
2539   if (!swig_callbackGetNextFocusableActor) {
2540     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2541   } else {
2542     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2543     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2544     jdirection = (int)direction;
2545     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2546     if (!jresult) {
2547       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__);
2548       return c_result;
2549     }
2550     c_result = *(Dali::Actor *)jresult;
2551   }
2552   return c_result;
2553 }
2554
2555 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2556   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2557 }
2558
2559 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2560   swig_callbackGetNextFocusableActor = 0;
2561 }
2562
2563
2564 #ifdef __cplusplus
2565 extern "C" {
2566 #endif
2567
2568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2569   void * jresult ;
2570   floatp *result = 0 ;
2571
2572   {
2573     try {
2574       result = (floatp *)new_floatp();
2575     } catch (std::out_of_range& e) {
2576       {
2577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2578       };
2579     } catch (std::exception& e) {
2580       {
2581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2582       };
2583     } catch (DaliException e) {
2584       {
2585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2586       };
2587     } catch (...) {
2588       {
2589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2590       };
2591     }
2592   }
2593   jresult = (void *)result;
2594   return jresult;
2595 }
2596
2597
2598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2599   floatp *arg1 = (floatp *) 0 ;
2600
2601   arg1 = (floatp *)jarg1;
2602   {
2603     try {
2604       delete_floatp(arg1);
2605     } catch (std::out_of_range& e) {
2606       {
2607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2608       };
2609     } catch (std::exception& e) {
2610       {
2611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2612       };
2613     } catch (Dali::DaliException e) {
2614       {
2615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2616       };
2617     } catch (...) {
2618       {
2619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2620       };
2621     }
2622   }
2623
2624 }
2625
2626
2627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2628   floatp *arg1 = (floatp *) 0 ;
2629   float arg2 ;
2630
2631   arg1 = (floatp *)jarg1;
2632   arg2 = (float)jarg2;
2633   {
2634     try {
2635       floatp_assign(arg1,arg2);
2636     } catch (std::out_of_range& e) {
2637       {
2638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2639       };
2640     } catch (std::exception& e) {
2641       {
2642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2643       };
2644     } catch (Dali::DaliException e) {
2645       {
2646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2647       };
2648     } catch (...) {
2649       {
2650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2651       };
2652     }
2653   }
2654
2655 }
2656
2657
2658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2659   float jresult ;
2660   floatp *arg1 = (floatp *) 0 ;
2661   float result;
2662
2663   arg1 = (floatp *)jarg1;
2664   {
2665     try {
2666       result = (float)floatp_value(arg1);
2667     } catch (std::out_of_range& e) {
2668       {
2669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2670       };
2671     } catch (std::exception& e) {
2672       {
2673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2674       };
2675     } catch (DaliException e) {
2676       {
2677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2678       };
2679     } catch (...) {
2680       {
2681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2682       };
2683     }
2684   }
2685   jresult = result;
2686   return jresult;
2687 }
2688
2689
2690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2691   void * jresult ;
2692   floatp *arg1 = (floatp *) 0 ;
2693   float *result = 0 ;
2694
2695   arg1 = (floatp *)jarg1;
2696   {
2697     try {
2698       result = (float *)floatp_cast(arg1);
2699     } catch (std::out_of_range& e) {
2700       {
2701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2702       };
2703     } catch (std::exception& e) {
2704       {
2705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2706       };
2707     } catch (Dali::DaliException e) {
2708       {
2709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2710       };
2711     } catch (...) {
2712       {
2713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2714       };
2715     }
2716   }
2717
2718   jresult = (void *)result;
2719   return jresult;
2720 }
2721
2722
2723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2724   void * jresult ;
2725   float *arg1 = (float *) 0 ;
2726   floatp *result = 0 ;
2727
2728   arg1 = (float *)jarg1;
2729   {
2730     try {
2731       result = (floatp *)floatp_frompointer(arg1);
2732     } catch (std::out_of_range& e) {
2733       {
2734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2735       };
2736     } catch (std::exception& e) {
2737       {
2738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2739       };
2740     } catch (Dali::DaliException e) {
2741       {
2742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2743       };
2744     } catch (...) {
2745       {
2746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2747       };
2748     }
2749   }
2750
2751   jresult = (void *)result;
2752   return jresult;
2753 }
2754
2755
2756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2757   void * jresult ;
2758   intp *result = 0 ;
2759
2760   {
2761     try {
2762       result = (intp *)new_intp();
2763     } catch (std::out_of_range& e) {
2764       {
2765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2766       };
2767     } catch (std::exception& e) {
2768       {
2769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2770       };
2771     } catch (Dali::DaliException e) {
2772       {
2773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2774       };
2775     } catch (...) {
2776       {
2777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2778       };
2779     }
2780   }
2781
2782   jresult = (void *)result;
2783   return jresult;
2784 }
2785
2786
2787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2788   intp *arg1 = (intp *) 0 ;
2789
2790   arg1 = (intp *)jarg1;
2791   {
2792     try {
2793       delete_intp(arg1);
2794     } catch (std::out_of_range& e) {
2795       {
2796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2797       };
2798     } catch (std::exception& e) {
2799       {
2800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2801       };
2802     } catch (Dali::DaliException e) {
2803       {
2804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2805       };
2806     } catch (...) {
2807       {
2808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2809       };
2810     }
2811   }
2812
2813 }
2814
2815
2816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2817   intp *arg1 = (intp *) 0 ;
2818   int arg2 ;
2819
2820   arg1 = (intp *)jarg1;
2821   arg2 = (int)jarg2;
2822   {
2823     try {
2824       intp_assign(arg1,arg2);
2825     } catch (std::out_of_range& e) {
2826       {
2827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2828       };
2829     } catch (std::exception& e) {
2830       {
2831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2832       };
2833     } catch (Dali::DaliException e) {
2834       {
2835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2836       };
2837     } catch (...) {
2838       {
2839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2840       };
2841     }
2842   }
2843
2844 }
2845
2846
2847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2848   int jresult ;
2849   intp *arg1 = (intp *) 0 ;
2850   int result;
2851
2852   arg1 = (intp *)jarg1;
2853   {
2854     try {
2855       result = (int)intp_value(arg1);
2856     } catch (std::out_of_range& e) {
2857       {
2858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2859       };
2860     } catch (std::exception& e) {
2861       {
2862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2863       };
2864     } catch (Dali::DaliException e) {
2865       {
2866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2867       };
2868     } catch (...) {
2869       {
2870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2871       };
2872     }
2873   }
2874
2875   jresult = result;
2876   return jresult;
2877 }
2878
2879
2880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2881   void * jresult ;
2882   intp *arg1 = (intp *) 0 ;
2883   int *result = 0 ;
2884
2885   arg1 = (intp *)jarg1;
2886   {
2887     try {
2888       result = (int *)intp_cast(arg1);
2889     } catch (std::out_of_range& e) {
2890       {
2891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2892       };
2893     } catch (std::exception& e) {
2894       {
2895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2896       };
2897     } catch (Dali::DaliException e) {
2898       {
2899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2900       };
2901     } catch (...) {
2902       {
2903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2904       };
2905     }
2906   }
2907
2908   jresult = (void *)result;
2909   return jresult;
2910 }
2911
2912
2913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2914   void * jresult ;
2915   int *arg1 = (int *) 0 ;
2916   intp *result = 0 ;
2917
2918   arg1 = (int *)jarg1;
2919   {
2920     try {
2921       result = (intp *)intp_frompointer(arg1);
2922     } catch (std::out_of_range& e) {
2923       {
2924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2925       };
2926     } catch (std::exception& e) {
2927       {
2928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2929       };
2930     } catch (Dali::DaliException e) {
2931       {
2932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2933       };
2934     } catch (...) {
2935       {
2936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2937       };
2938     }
2939   }
2940
2941   jresult = (void *)result;
2942   return jresult;
2943 }
2944
2945
2946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2947   void * jresult ;
2948   doublep *result = 0 ;
2949
2950   {
2951     try {
2952       result = (doublep *)new_doublep();
2953     } catch (std::out_of_range& e) {
2954       {
2955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2956       };
2957     } catch (std::exception& e) {
2958       {
2959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2960       };
2961     } catch (Dali::DaliException e) {
2962       {
2963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2964       };
2965     } catch (...) {
2966       {
2967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2968       };
2969     }
2970   }
2971
2972   jresult = (void *)result;
2973   return jresult;
2974 }
2975
2976
2977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2978   doublep *arg1 = (doublep *) 0 ;
2979
2980   arg1 = (doublep *)jarg1;
2981   {
2982     try {
2983       delete_doublep(arg1);
2984     } catch (std::out_of_range& e) {
2985       {
2986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2987       };
2988     } catch (std::exception& e) {
2989       {
2990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2991       };
2992     } catch (Dali::DaliException e) {
2993       {
2994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2995       };
2996     } catch (...) {
2997       {
2998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2999       };
3000     }
3001   }
3002
3003 }
3004
3005
3006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3007   doublep *arg1 = (doublep *) 0 ;
3008   double arg2 ;
3009
3010   arg1 = (doublep *)jarg1;
3011   arg2 = (double)jarg2;
3012   {
3013     try {
3014       doublep_assign(arg1,arg2);
3015     } catch (std::out_of_range& e) {
3016       {
3017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3018       };
3019     } catch (std::exception& e) {
3020       {
3021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3022       };
3023     } catch (Dali::DaliException e) {
3024       {
3025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3026       };
3027     } catch (...) {
3028       {
3029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3030       };
3031     }
3032   }
3033
3034 }
3035
3036
3037 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3038   double jresult ;
3039   doublep *arg1 = (doublep *) 0 ;
3040   double result;
3041
3042   arg1 = (doublep *)jarg1;
3043   {
3044     try {
3045       result = (double)doublep_value(arg1);
3046     } catch (std::out_of_range& e) {
3047       {
3048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3049       };
3050     } catch (std::exception& e) {
3051       {
3052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3053       };
3054     } catch (Dali::DaliException e) {
3055       {
3056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3057       };
3058     } catch (...) {
3059       {
3060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3061       };
3062     }
3063   }
3064
3065   jresult = result;
3066   return jresult;
3067 }
3068
3069
3070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3071   void * jresult ;
3072   doublep *arg1 = (doublep *) 0 ;
3073   double *result = 0 ;
3074
3075   arg1 = (doublep *)jarg1;
3076   {
3077     try {
3078       result = (double *)doublep_cast(arg1);
3079     } catch (std::out_of_range& e) {
3080       {
3081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3082       };
3083     } catch (std::exception& e) {
3084       {
3085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3086       };
3087     } catch (Dali::DaliException e) {
3088       {
3089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3090       };
3091     } catch (...) {
3092       {
3093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3094       };
3095     }
3096   }
3097
3098   jresult = (void *)result;
3099   return jresult;
3100 }
3101
3102
3103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3104   void * jresult ;
3105   double *arg1 = (double *) 0 ;
3106   doublep *result = 0 ;
3107
3108   arg1 = (double *)jarg1;
3109   {
3110     try {
3111       result = (doublep *)doublep_frompointer(arg1);
3112     } catch (std::out_of_range& e) {
3113       {
3114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3115       };
3116     } catch (std::exception& e) {
3117       {
3118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3119       };
3120     } catch (Dali::DaliException e) {
3121       {
3122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3123       };
3124     } catch (...) {
3125       {
3126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3127       };
3128     }
3129   }
3130
3131   jresult = (void *)result;
3132   return jresult;
3133 }
3134
3135
3136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3137   void * jresult ;
3138   uintp *result = 0 ;
3139
3140   {
3141     try {
3142       result = (uintp *)new_uintp();
3143     } catch (std::out_of_range& e) {
3144       {
3145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3146       };
3147     } catch (std::exception& e) {
3148       {
3149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3150       };
3151     } catch (Dali::DaliException e) {
3152       {
3153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3154       };
3155     } catch (...) {
3156       {
3157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3158       };
3159     }
3160   }
3161
3162   jresult = (void *)result;
3163   return jresult;
3164 }
3165
3166
3167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3168   uintp *arg1 = (uintp *) 0 ;
3169
3170   arg1 = (uintp *)jarg1;
3171   {
3172     try {
3173       delete_uintp(arg1);
3174     } catch (std::out_of_range& e) {
3175       {
3176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3177       };
3178     } catch (std::exception& e) {
3179       {
3180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3181       };
3182     } catch (Dali::DaliException e) {
3183       {
3184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3185       };
3186     } catch (...) {
3187       {
3188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3189       };
3190     }
3191   }
3192
3193 }
3194
3195
3196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3197   uintp *arg1 = (uintp *) 0 ;
3198   unsigned int arg2 ;
3199
3200   arg1 = (uintp *)jarg1;
3201   arg2 = (unsigned int)jarg2;
3202   {
3203     try {
3204       uintp_assign(arg1,arg2);
3205     } catch (std::out_of_range& e) {
3206       {
3207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3208       };
3209     } catch (std::exception& e) {
3210       {
3211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3212       };
3213     } catch (Dali::DaliException e) {
3214       {
3215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3216       };
3217     } catch (...) {
3218       {
3219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3220       };
3221     }
3222   }
3223
3224 }
3225
3226
3227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3228   unsigned int jresult ;
3229   uintp *arg1 = (uintp *) 0 ;
3230   unsigned int result;
3231
3232   arg1 = (uintp *)jarg1;
3233   {
3234     try {
3235       result = (unsigned int)uintp_value(arg1);
3236     } catch (std::out_of_range& e) {
3237       {
3238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3239       };
3240     } catch (std::exception& e) {
3241       {
3242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3243       };
3244     } catch (Dali::DaliException e) {
3245       {
3246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3247       };
3248     } catch (...) {
3249       {
3250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3251       };
3252     }
3253   }
3254
3255   jresult = result;
3256   return jresult;
3257 }
3258
3259
3260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3261   void * jresult ;
3262   uintp *arg1 = (uintp *) 0 ;
3263   unsigned int *result = 0 ;
3264
3265   arg1 = (uintp *)jarg1;
3266   {
3267     try {
3268       result = (unsigned int *)uintp_cast(arg1);
3269     } catch (std::out_of_range& e) {
3270       {
3271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3272       };
3273     } catch (std::exception& e) {
3274       {
3275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3276       };
3277     } catch (Dali::DaliException e) {
3278       {
3279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3280       };
3281     } catch (...) {
3282       {
3283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3284       };
3285     }
3286   }
3287
3288   jresult = (void *)result;
3289   return jresult;
3290 }
3291
3292
3293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3294   void * jresult ;
3295   unsigned int *arg1 = (unsigned int *) 0 ;
3296   uintp *result = 0 ;
3297
3298   arg1 = (unsigned int *)jarg1;
3299   {
3300     try {
3301       result = (uintp *)uintp_frompointer(arg1);
3302     } catch (std::out_of_range& e) {
3303       {
3304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3305       };
3306     } catch (std::exception& e) {
3307       {
3308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3309       };
3310     } catch (Dali::DaliException e) {
3311       {
3312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3313       };
3314     } catch (...) {
3315       {
3316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3317       };
3318     }
3319   }
3320
3321   jresult = (void *)result;
3322   return jresult;
3323 }
3324
3325
3326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3327   void * jresult ;
3328   ushortp *result = 0 ;
3329
3330   {
3331     try {
3332       result = (ushortp *)new_ushortp();
3333     } catch (std::out_of_range& e) {
3334       {
3335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3336       };
3337     } catch (std::exception& e) {
3338       {
3339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3340       };
3341     } catch (Dali::DaliException e) {
3342       {
3343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3344       };
3345     } catch (...) {
3346       {
3347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3348       };
3349     }
3350   }
3351
3352   jresult = (void *)result;
3353   return jresult;
3354 }
3355
3356
3357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3358   ushortp *arg1 = (ushortp *) 0 ;
3359
3360   arg1 = (ushortp *)jarg1;
3361   {
3362     try {
3363       delete_ushortp(arg1);
3364     } catch (std::out_of_range& e) {
3365       {
3366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3367       };
3368     } catch (std::exception& e) {
3369       {
3370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3371       };
3372     } catch (Dali::DaliException e) {
3373       {
3374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3375       };
3376     } catch (...) {
3377       {
3378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3379       };
3380     }
3381   }
3382
3383 }
3384
3385
3386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3387   ushortp *arg1 = (ushortp *) 0 ;
3388   unsigned short arg2 ;
3389
3390   arg1 = (ushortp *)jarg1;
3391   arg2 = (unsigned short)jarg2;
3392   {
3393     try {
3394       ushortp_assign(arg1,arg2);
3395     } catch (std::out_of_range& e) {
3396       {
3397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3398       };
3399     } catch (std::exception& e) {
3400       {
3401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3402       };
3403     } catch (Dali::DaliException e) {
3404       {
3405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3406       };
3407     } catch (...) {
3408       {
3409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3410       };
3411     }
3412   }
3413
3414 }
3415
3416
3417 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3418   unsigned short jresult ;
3419   ushortp *arg1 = (ushortp *) 0 ;
3420   unsigned short result;
3421
3422   arg1 = (ushortp *)jarg1;
3423   {
3424     try {
3425       result = (unsigned short)ushortp_value(arg1);
3426     } catch (std::out_of_range& e) {
3427       {
3428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3429       };
3430     } catch (std::exception& e) {
3431       {
3432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3433       };
3434     } catch (Dali::DaliException e) {
3435       {
3436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3437       };
3438     } catch (...) {
3439       {
3440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3441       };
3442     }
3443   }
3444
3445   jresult = result;
3446   return jresult;
3447 }
3448
3449
3450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3451   void * jresult ;
3452   ushortp *arg1 = (ushortp *) 0 ;
3453   unsigned short *result = 0 ;
3454
3455   arg1 = (ushortp *)jarg1;
3456   {
3457     try {
3458       result = (unsigned short *)ushortp_cast(arg1);
3459     } catch (std::out_of_range& e) {
3460       {
3461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3462       };
3463     } catch (std::exception& e) {
3464       {
3465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3466       };
3467     } catch (Dali::DaliException e) {
3468       {
3469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3470       };
3471     } catch (...) {
3472       {
3473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3474       };
3475     }
3476   }
3477
3478   jresult = (void *)result;
3479   return jresult;
3480 }
3481
3482
3483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3484   void * jresult ;
3485   unsigned short *arg1 = (unsigned short *) 0 ;
3486   ushortp *result = 0 ;
3487
3488   arg1 = (unsigned short *)jarg1;
3489   {
3490     try {
3491       result = (ushortp *)ushortp_frompointer(arg1);
3492     } catch (std::out_of_range& e) {
3493       {
3494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3495       };
3496     } catch (std::exception& e) {
3497       {
3498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3499       };
3500     } catch (Dali::DaliException e) {
3501       {
3502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3503       };
3504     } catch (...) {
3505       {
3506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3507       };
3508     }
3509   }
3510
3511   jresult = (void *)result;
3512   return jresult;
3513 }
3514
3515
3516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3517   unsigned int jresult ;
3518   int arg1 ;
3519   unsigned int result;
3520
3521   arg1 = (int)jarg1;
3522   {
3523     try {
3524       result = (unsigned int)int_to_uint(arg1);
3525     } catch (std::out_of_range& e) {
3526       {
3527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3528       };
3529     } catch (std::exception& e) {
3530       {
3531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3532       };
3533     } catch (Dali::DaliException e) {
3534       {
3535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3536       };
3537     } catch (...) {
3538       {
3539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3540       };
3541     }
3542   }
3543
3544   jresult = result;
3545   return jresult;
3546 }
3547
3548
3549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3550   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3551
3552   arg1 = (Dali::RefObject *)jarg1;
3553   {
3554     try {
3555       (arg1)->Reference();
3556     } catch (std::out_of_range& e) {
3557       {
3558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3559       };
3560     } catch (std::exception& e) {
3561       {
3562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3563       };
3564     } catch (Dali::DaliException e) {
3565       {
3566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3567       };
3568     } catch (...) {
3569       {
3570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3571       };
3572     }
3573   }
3574
3575 }
3576
3577
3578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3579   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3580
3581   arg1 = (Dali::RefObject *)jarg1;
3582   {
3583     try {
3584       (arg1)->Unreference();
3585     } catch (std::out_of_range& e) {
3586       {
3587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3588       };
3589     } catch (std::exception& e) {
3590       {
3591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3592       };
3593     } catch (Dali::DaliException e) {
3594       {
3595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3596       };
3597     } catch (...) {
3598       {
3599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3600       };
3601     }
3602   }
3603
3604 }
3605
3606
3607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3608   int jresult ;
3609   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3610   int result;
3611
3612   arg1 = (Dali::RefObject *)jarg1;
3613   {
3614     try {
3615       result = (int)(arg1)->ReferenceCount();
3616     } catch (std::out_of_range& e) {
3617       {
3618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3619       };
3620     } catch (std::exception& e) {
3621       {
3622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3623       };
3624     } catch (Dali::DaliException e) {
3625       {
3626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3627       };
3628     } catch (...) {
3629       {
3630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3631       };
3632     }
3633   }
3634
3635   jresult = result;
3636   return jresult;
3637 }
3638
3639
3640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3641   void * jresult ;
3642   Dali::Any *result = 0 ;
3643
3644   {
3645     try {
3646       result = (Dali::Any *)new Dali::Any();
3647     } catch (std::out_of_range& e) {
3648       {
3649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3650       };
3651     } catch (std::exception& e) {
3652       {
3653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3654       };
3655     } catch (Dali::DaliException e) {
3656       {
3657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3658       };
3659     } catch (...) {
3660       {
3661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3662       };
3663     }
3664   }
3665
3666   jresult = (void *)result;
3667   return jresult;
3668 }
3669
3670
3671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3672   Dali::Any *arg1 = (Dali::Any *) 0 ;
3673
3674   arg1 = (Dali::Any *)jarg1;
3675   {
3676     try {
3677       delete arg1;
3678     } catch (std::out_of_range& e) {
3679       {
3680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3681       };
3682     } catch (std::exception& e) {
3683       {
3684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3685       };
3686     } catch (Dali::DaliException e) {
3687       {
3688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3689       };
3690     } catch (...) {
3691       {
3692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3693       };
3694     }
3695   }
3696
3697 }
3698
3699
3700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3701   char *arg1 = (char *) 0 ;
3702
3703   arg1 = (char *)jarg1;
3704   {
3705     try {
3706       Dali::Any::AssertAlways((char const *)arg1);
3707     } catch (std::out_of_range& e) {
3708       {
3709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3710       };
3711     } catch (std::exception& e) {
3712       {
3713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3714       };
3715     } catch (Dali::DaliException e) {
3716       {
3717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3718       };
3719     } catch (...) {
3720       {
3721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3722       };
3723     }
3724   }
3725
3726 }
3727
3728
3729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3730   void * jresult ;
3731   Dali::Any *arg1 = 0 ;
3732   Dali::Any *result = 0 ;
3733
3734   arg1 = (Dali::Any *)jarg1;
3735   if (!arg1) {
3736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3737     return 0;
3738   }
3739   {
3740     try {
3741       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3742     } catch (std::out_of_range& e) {
3743       {
3744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3745       };
3746     } catch (std::exception& e) {
3747       {
3748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3749       };
3750     } catch (Dali::DaliException e) {
3751       {
3752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3753       };
3754     } catch (...) {
3755       {
3756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3757       };
3758     }
3759   }
3760
3761   jresult = (void *)result;
3762   return jresult;
3763 }
3764
3765
3766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3767   void * jresult ;
3768   Dali::Any *arg1 = (Dali::Any *) 0 ;
3769   Dali::Any *arg2 = 0 ;
3770   Dali::Any *result = 0 ;
3771
3772   arg1 = (Dali::Any *)jarg1;
3773   arg2 = (Dali::Any *)jarg2;
3774   if (!arg2) {
3775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3776     return 0;
3777   }
3778   {
3779     try {
3780       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3781     } catch (std::out_of_range& e) {
3782       {
3783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3784       };
3785     } catch (std::exception& e) {
3786       {
3787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3788       };
3789     } catch (Dali::DaliException e) {
3790       {
3791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3792       };
3793     } catch (...) {
3794       {
3795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3796       };
3797     }
3798   }
3799
3800   jresult = (void *)result;
3801   return jresult;
3802 }
3803
3804
3805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3806   void * jresult ;
3807   Dali::Any *arg1 = (Dali::Any *) 0 ;
3808   std::type_info *result = 0 ;
3809
3810   arg1 = (Dali::Any *)jarg1;
3811   {
3812     try {
3813       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3814     } catch (std::out_of_range& e) {
3815       {
3816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3817       };
3818     } catch (std::exception& e) {
3819       {
3820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3821       };
3822     } catch (Dali::DaliException e) {
3823       {
3824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3825       };
3826     } catch (...) {
3827       {
3828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3829       };
3830     }
3831   }
3832
3833   jresult = (void *)result;
3834   return jresult;
3835 }
3836
3837
3838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3839   unsigned int jresult ;
3840   Dali::Any *arg1 = (Dali::Any *) 0 ;
3841   bool result;
3842
3843   arg1 = (Dali::Any *)jarg1;
3844   {
3845     try {
3846       result = (bool)((Dali::Any const *)arg1)->Empty();
3847     } catch (std::out_of_range& e) {
3848       {
3849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3850       };
3851     } catch (std::exception& e) {
3852       {
3853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3854       };
3855     } catch (Dali::DaliException e) {
3856       {
3857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3858       };
3859     } catch (...) {
3860       {
3861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3862       };
3863     }
3864   }
3865
3866   jresult = result;
3867   return jresult;
3868 }
3869
3870
3871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3872   void * jresult ;
3873   std::type_info *arg1 = 0 ;
3874   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3875   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3876   Dali::Any::AnyContainerBase *result = 0 ;
3877
3878   arg1 = (std::type_info *)jarg1;
3879   if (!arg1) {
3880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3881     return 0;
3882   }
3883   arg2 = (Dali::Any::CloneFunc)jarg2;
3884   arg3 = (Dali::Any::DeleteFunc)jarg3;
3885   {
3886     try {
3887       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3888     } catch (std::out_of_range& e) {
3889       {
3890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3891       };
3892     } catch (std::exception& e) {
3893       {
3894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3895       };
3896     } catch (Dali::DaliException e) {
3897       {
3898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3899       };
3900     } catch (...) {
3901       {
3902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3903       };
3904     }
3905   }
3906
3907   jresult = (void *)result;
3908   return jresult;
3909 }
3910
3911
3912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3913   void * jresult ;
3914   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3915   std::type_info *result = 0 ;
3916
3917   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3918   {
3919     try {
3920       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3921     } catch (std::out_of_range& e) {
3922       {
3923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3924       };
3925     } catch (std::exception& e) {
3926       {
3927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3928       };
3929     } catch (Dali::DaliException e) {
3930       {
3931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3932       };
3933     } catch (...) {
3934       {
3935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3936       };
3937     }
3938   }
3939
3940   jresult = (void *)result;
3941   return jresult;
3942 }
3943
3944
3945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3946   void * jresult ;
3947   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3948   ::std::type_info *result = 0 ;
3949
3950   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3951   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3952   jresult = (void *)result;
3953   return jresult;
3954 }
3955
3956
3957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3958   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3959   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3960
3961   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3962   arg2 = (Dali::Any::CloneFunc)jarg2;
3963   if (arg1) (arg1)->mCloneFunc = arg2;
3964 }
3965
3966
3967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3968   void * jresult ;
3969   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3970   Dali::Any::CloneFunc result;
3971
3972   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3973   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3974   jresult = (void *)result;
3975   return jresult;
3976 }
3977
3978
3979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3980   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3981   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3982
3983   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3984   arg2 = (Dali::Any::DeleteFunc)jarg2;
3985   if (arg1) (arg1)->mDeleteFunc = arg2;
3986 }
3987
3988
3989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3990   void * jresult ;
3991   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3992   Dali::Any::DeleteFunc result;
3993
3994   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3995   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3996   jresult = (void *)result;
3997   return jresult;
3998 }
3999
4000
4001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4002   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4003
4004   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4005   {
4006     try {
4007       delete arg1;
4008     } catch (std::out_of_range& e) {
4009       {
4010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4011       };
4012     } catch (std::exception& e) {
4013       {
4014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4015       };
4016     } catch (Dali::DaliException e) {
4017       {
4018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4019       };
4020     } catch (...) {
4021       {
4022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4023       };
4024     }
4025   }
4026
4027 }
4028
4029
4030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4031   Dali::Any *arg1 = (Dali::Any *) 0 ;
4032   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4033
4034   arg1 = (Dali::Any *)jarg1;
4035   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4036   if (arg1) (arg1)->mContainer = arg2;
4037 }
4038
4039
4040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4041   void * jresult ;
4042   Dali::Any *arg1 = (Dali::Any *) 0 ;
4043   Dali::Any::AnyContainerBase *result = 0 ;
4044
4045   arg1 = (Dali::Any *)jarg1;
4046   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4047   jresult = (void *)result;
4048   return jresult;
4049 }
4050
4051
4052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4053   char *arg1 = (char *) 0 ;
4054   char *arg2 = (char *) 0 ;
4055
4056   arg1 = (char *)jarg1;
4057   arg2 = (char *)jarg2;
4058   {
4059     try {
4060       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4061     } catch (std::out_of_range& e) {
4062       {
4063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4064       };
4065     } catch (std::exception& e) {
4066       {
4067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4068       };
4069     } catch (Dali::DaliException e) {
4070       {
4071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4072       };
4073     } catch (...) {
4074       {
4075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4076       };
4077     }
4078   }
4079
4080 }
4081
4082
4083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4084   void * jresult ;
4085   char *arg1 = (char *) 0 ;
4086   char *arg2 = (char *) 0 ;
4087   Dali::DaliException *result = 0 ;
4088
4089   arg1 = (char *)jarg1;
4090   arg2 = (char *)jarg2;
4091   {
4092     try {
4093       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4094     } catch (std::out_of_range& e) {
4095       {
4096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4097       };
4098     } catch (std::exception& e) {
4099       {
4100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4101       };
4102     } catch (Dali::DaliException e) {
4103       {
4104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4105       };
4106     } catch (...) {
4107       {
4108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4109       };
4110     }
4111   }
4112
4113   jresult = (void *)result;
4114   return jresult;
4115 }
4116
4117
4118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4119   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4120   std::string arg2 = std::string(jarg2);
4121
4122   arg1 = (Dali::DaliException *)jarg1;
4123   {
4124     if (!arg2.empty()) {
4125       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4126     } else {
4127       arg1->location = 0;
4128     }
4129   }
4130 }
4131
4132 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4133   char * jresult ;
4134   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4135   char *result = 0 ;
4136
4137   arg1 = (Dali::DaliException *)jarg1;
4138   result = (char *) ((arg1)->location);
4139   jresult = SWIG_csharp_string_callback((const char *)result);
4140   return jresult;
4141 }
4142
4143
4144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4145   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4146   std::string arg2 = std::string(jarg2);
4147
4148   arg1 = (Dali::DaliException *)jarg1;
4149   {
4150     if (!arg2.empty()) {
4151       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4152     } else {
4153       arg1->condition = 0;
4154     }
4155   }
4156 }
4157
4158
4159 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4160   char * jresult ;
4161   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4162   char *result = 0 ;
4163
4164   arg1 = (Dali::DaliException *)jarg1;
4165   result = (char *) ((arg1)->condition);
4166   jresult = SWIG_csharp_string_callback((const char *)result);
4167   return jresult;
4168 }
4169
4170
4171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4172   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4173
4174   arg1 = (Dali::DaliException *)jarg1;
4175   {
4176     try {
4177       delete arg1;
4178     } catch (std::out_of_range& e) {
4179       {
4180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4181       };
4182     } catch (std::exception& e) {
4183       {
4184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4185       };
4186     } catch (Dali::DaliException e) {
4187       {
4188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4189       };
4190     } catch (...) {
4191       {
4192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4193       };
4194     }
4195   }
4196
4197 }
4198
4199
4200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4201   void * jresult ;
4202   Dali::Vector2 *result = 0 ;
4203
4204   {
4205     try {
4206       result = (Dali::Vector2 *)new Dali::Vector2();
4207     } catch (std::out_of_range& e) {
4208       {
4209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4210       };
4211     } catch (std::exception& e) {
4212       {
4213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4214       };
4215     } catch (Dali::DaliException e) {
4216       {
4217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4218       };
4219     } catch (...) {
4220       {
4221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4222       };
4223     }
4224   }
4225
4226   jresult = (void *)result;
4227   return jresult;
4228 }
4229
4230
4231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4232   void * jresult ;
4233   float arg1 ;
4234   float arg2 ;
4235   Dali::Vector2 *result = 0 ;
4236
4237   arg1 = (float)jarg1;
4238   arg2 = (float)jarg2;
4239   {
4240     try {
4241       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4242     } catch (std::out_of_range& e) {
4243       {
4244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4245       };
4246     } catch (std::exception& e) {
4247       {
4248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4249       };
4250     } catch (Dali::DaliException e) {
4251       {
4252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4253       };
4254     } catch (...) {
4255       {
4256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4257       };
4258     }
4259   }
4260
4261   jresult = (void *)result;
4262   return jresult;
4263 }
4264
4265
4266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4267   void * jresult ;
4268   float *arg1 = (float *) 0 ;
4269   Dali::Vector2 *result = 0 ;
4270
4271   arg1 = jarg1;
4272   {
4273     try {
4274       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4275     } catch (std::out_of_range& e) {
4276       {
4277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4278       };
4279     } catch (std::exception& e) {
4280       {
4281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4282       };
4283     } catch (Dali::DaliException e) {
4284       {
4285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4286       };
4287     } catch (...) {
4288       {
4289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4290       };
4291     }
4292   }
4293
4294   jresult = (void *)result;
4295
4296
4297   return jresult;
4298 }
4299
4300
4301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4302   void * jresult ;
4303   Dali::Vector3 *arg1 = 0 ;
4304   Dali::Vector2 *result = 0 ;
4305
4306   arg1 = (Dali::Vector3 *)jarg1;
4307   if (!arg1) {
4308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4309     return 0;
4310   }
4311   {
4312     try {
4313       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4314     } catch (std::out_of_range& e) {
4315       {
4316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4317       };
4318     } catch (std::exception& e) {
4319       {
4320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4321       };
4322     } catch (Dali::DaliException e) {
4323       {
4324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4325       };
4326     } catch (...) {
4327       {
4328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4329       };
4330     }
4331   }
4332
4333   jresult = (void *)result;
4334   return jresult;
4335 }
4336
4337
4338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4339   void * jresult ;
4340   Dali::Vector4 *arg1 = 0 ;
4341   Dali::Vector2 *result = 0 ;
4342
4343   arg1 = (Dali::Vector4 *)jarg1;
4344   if (!arg1) {
4345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4346     return 0;
4347   }
4348   {
4349     try {
4350       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4351     } catch (std::out_of_range& e) {
4352       {
4353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4354       };
4355     } catch (std::exception& e) {
4356       {
4357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4358       };
4359     } catch (Dali::DaliException e) {
4360       {
4361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4362       };
4363     } catch (...) {
4364       {
4365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4366       };
4367     }
4368   }
4369
4370   jresult = (void *)result;
4371   return jresult;
4372 }
4373
4374
4375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4376   void * jresult ;
4377   Dali::Vector2 *result = 0 ;
4378
4379   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4380   jresult = (void *)result;
4381   return jresult;
4382 }
4383
4384
4385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4386   void * jresult ;
4387   Dali::Vector2 *result = 0 ;
4388
4389   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4390   jresult = (void *)result;
4391   return jresult;
4392 }
4393
4394
4395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4396   void * jresult ;
4397   Dali::Vector2 *result = 0 ;
4398
4399   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4400   jresult = (void *)result;
4401   return jresult;
4402 }
4403
4404
4405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4406   void * jresult ;
4407   Dali::Vector2 *result = 0 ;
4408
4409   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4410   jresult = (void *)result;
4411   return jresult;
4412 }
4413
4414
4415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4416   void * jresult ;
4417   Dali::Vector2 *result = 0 ;
4418
4419   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4420   jresult = (void *)result;
4421   return jresult;
4422 }
4423
4424
4425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4426   void * jresult ;
4427   Dali::Vector2 *result = 0 ;
4428
4429   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4430   jresult = (void *)result;
4431   return jresult;
4432 }
4433
4434
4435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4436   void * jresult ;
4437   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4438   float *arg2 = (float *) 0 ;
4439   Dali::Vector2 *result = 0 ;
4440
4441   arg1 = (Dali::Vector2 *)jarg1;
4442   arg2 = jarg2;
4443   {
4444     try {
4445       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4446     } catch (std::out_of_range& e) {
4447       {
4448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4449       };
4450     } catch (std::exception& e) {
4451       {
4452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4453       };
4454     } catch (Dali::DaliException e) {
4455       {
4456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4457       };
4458     } catch (...) {
4459       {
4460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4461       };
4462     }
4463   }
4464
4465   jresult = (void *)result;
4466
4467
4468   return jresult;
4469 }
4470
4471
4472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4473   void * jresult ;
4474   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4475   Dali::Vector3 *arg2 = 0 ;
4476   Dali::Vector2 *result = 0 ;
4477
4478   arg1 = (Dali::Vector2 *)jarg1;
4479   arg2 = (Dali::Vector3 *)jarg2;
4480   if (!arg2) {
4481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4482     return 0;
4483   }
4484   {
4485     try {
4486       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4487     } catch (std::out_of_range& e) {
4488       {
4489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4490       };
4491     } catch (std::exception& e) {
4492       {
4493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4494       };
4495     } catch (Dali::DaliException e) {
4496       {
4497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4498       };
4499     } catch (...) {
4500       {
4501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4502       };
4503     }
4504   }
4505
4506   jresult = (void *)result;
4507   return jresult;
4508 }
4509
4510
4511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4512   void * jresult ;
4513   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4514   Dali::Vector4 *arg2 = 0 ;
4515   Dali::Vector2 *result = 0 ;
4516
4517   arg1 = (Dali::Vector2 *)jarg1;
4518   arg2 = (Dali::Vector4 *)jarg2;
4519   if (!arg2) {
4520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4521     return 0;
4522   }
4523   {
4524     try {
4525       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4526     } catch (std::out_of_range& e) {
4527       {
4528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4529       };
4530     } catch (std::exception& e) {
4531       {
4532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4533       };
4534     } catch (Dali::DaliException e) {
4535       {
4536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4537       };
4538     } catch (...) {
4539       {
4540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4541       };
4542     }
4543   }
4544
4545   jresult = (void *)result;
4546   return jresult;
4547 }
4548
4549
4550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4551   void * jresult ;
4552   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4553   Dali::Vector2 *arg2 = 0 ;
4554   Dali::Vector2 result;
4555
4556   arg1 = (Dali::Vector2 *)jarg1;
4557   arg2 = (Dali::Vector2 *)jarg2;
4558   if (!arg2) {
4559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4560     return 0;
4561   }
4562   {
4563     try {
4564       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4565     } catch (std::out_of_range& e) {
4566       {
4567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4568       };
4569     } catch (std::exception& e) {
4570       {
4571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4572       };
4573     } catch (Dali::DaliException e) {
4574       {
4575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4576       };
4577     } catch (...) {
4578       {
4579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4580       };
4581     }
4582   }
4583
4584   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4585   return jresult;
4586 }
4587
4588
4589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4590   void * jresult ;
4591   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4592   Dali::Vector2 *arg2 = 0 ;
4593   Dali::Vector2 *result = 0 ;
4594
4595   arg1 = (Dali::Vector2 *)jarg1;
4596   arg2 = (Dali::Vector2 *)jarg2;
4597   if (!arg2) {
4598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4599     return 0;
4600   }
4601   {
4602     try {
4603       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4604     } catch (std::out_of_range& e) {
4605       {
4606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4607       };
4608     } catch (std::exception& e) {
4609       {
4610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4611       };
4612     } catch (Dali::DaliException e) {
4613       {
4614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4615       };
4616     } catch (...) {
4617       {
4618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4619       };
4620     }
4621   }
4622
4623   jresult = (void *)result;
4624   return jresult;
4625 }
4626
4627
4628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4629   void * jresult ;
4630   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4631   Dali::Vector2 *arg2 = 0 ;
4632   Dali::Vector2 result;
4633
4634   arg1 = (Dali::Vector2 *)jarg1;
4635   arg2 = (Dali::Vector2 *)jarg2;
4636   if (!arg2) {
4637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4638     return 0;
4639   }
4640   {
4641     try {
4642       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4643     } catch (std::out_of_range& e) {
4644       {
4645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4646       };
4647     } catch (std::exception& e) {
4648       {
4649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4650       };
4651     } catch (Dali::DaliException e) {
4652       {
4653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4654       };
4655     } catch (...) {
4656       {
4657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4658       };
4659     }
4660   }
4661
4662   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4663   return jresult;
4664 }
4665
4666
4667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4668   void * jresult ;
4669   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4670   Dali::Vector2 *arg2 = 0 ;
4671   Dali::Vector2 *result = 0 ;
4672
4673   arg1 = (Dali::Vector2 *)jarg1;
4674   arg2 = (Dali::Vector2 *)jarg2;
4675   if (!arg2) {
4676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4677     return 0;
4678   }
4679   {
4680     try {
4681       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4682     } catch (std::out_of_range& e) {
4683       {
4684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4685       };
4686     } catch (std::exception& e) {
4687       {
4688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4689       };
4690     } catch (Dali::DaliException e) {
4691       {
4692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4693       };
4694     } catch (...) {
4695       {
4696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4697       };
4698     }
4699   }
4700
4701   jresult = (void *)result;
4702   return jresult;
4703 }
4704
4705
4706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4707   void * jresult ;
4708   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4709   Dali::Vector2 *arg2 = 0 ;
4710   Dali::Vector2 result;
4711
4712   arg1 = (Dali::Vector2 *)jarg1;
4713   arg2 = (Dali::Vector2 *)jarg2;
4714   if (!arg2) {
4715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4716     return 0;
4717   }
4718   {
4719     try {
4720       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4721     } catch (std::out_of_range& e) {
4722       {
4723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4724       };
4725     } catch (std::exception& e) {
4726       {
4727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4728       };
4729     } catch (Dali::DaliException e) {
4730       {
4731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4732       };
4733     } catch (...) {
4734       {
4735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4736       };
4737     }
4738   }
4739
4740   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4741   return jresult;
4742 }
4743
4744
4745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4746   void * jresult ;
4747   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4748   float arg2 ;
4749   Dali::Vector2 result;
4750
4751   arg1 = (Dali::Vector2 *)jarg1;
4752   arg2 = (float)jarg2;
4753   {
4754     try {
4755       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4756     } catch (std::out_of_range& e) {
4757       {
4758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4759       };
4760     } catch (std::exception& e) {
4761       {
4762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4763       };
4764     } catch (Dali::DaliException e) {
4765       {
4766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4767       };
4768     } catch (...) {
4769       {
4770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4771       };
4772     }
4773   }
4774
4775   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4776   return jresult;
4777 }
4778
4779
4780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4781   void * jresult ;
4782   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4783   Dali::Vector2 *arg2 = 0 ;
4784   Dali::Vector2 *result = 0 ;
4785
4786   arg1 = (Dali::Vector2 *)jarg1;
4787   arg2 = (Dali::Vector2 *)jarg2;
4788   if (!arg2) {
4789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4790     return 0;
4791   }
4792   {
4793     try {
4794       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4795     } catch (std::out_of_range& e) {
4796       {
4797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4798       };
4799     } catch (std::exception& e) {
4800       {
4801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4802       };
4803     } catch (Dali::DaliException e) {
4804       {
4805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4806       };
4807     } catch (...) {
4808       {
4809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4810       };
4811     }
4812   }
4813
4814   jresult = (void *)result;
4815   return jresult;
4816 }
4817
4818
4819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4820   void * jresult ;
4821   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4822   float arg2 ;
4823   Dali::Vector2 *result = 0 ;
4824
4825   arg1 = (Dali::Vector2 *)jarg1;
4826   arg2 = (float)jarg2;
4827   {
4828     try {
4829       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4830     } catch (std::out_of_range& e) {
4831       {
4832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4833       };
4834     } catch (std::exception& e) {
4835       {
4836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4837       };
4838     } catch (Dali::DaliException e) {
4839       {
4840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4841       };
4842     } catch (...) {
4843       {
4844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4845       };
4846     }
4847   }
4848
4849   jresult = (void *)result;
4850   return jresult;
4851 }
4852
4853
4854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4855   void * jresult ;
4856   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4857   Dali::Vector2 *arg2 = 0 ;
4858   Dali::Vector2 result;
4859
4860   arg1 = (Dali::Vector2 *)jarg1;
4861   arg2 = (Dali::Vector2 *)jarg2;
4862   if (!arg2) {
4863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4864     return 0;
4865   }
4866   {
4867     try {
4868       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4869     } catch (std::out_of_range& e) {
4870       {
4871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4872       };
4873     } catch (std::exception& e) {
4874       {
4875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4876       };
4877     } catch (Dali::DaliException e) {
4878       {
4879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4880       };
4881     } catch (...) {
4882       {
4883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4884       };
4885     }
4886   }
4887
4888   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4889   return jresult;
4890 }
4891
4892
4893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4894   void * jresult ;
4895   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4896   float arg2 ;
4897   Dali::Vector2 result;
4898
4899   arg1 = (Dali::Vector2 *)jarg1;
4900   arg2 = (float)jarg2;
4901   {
4902     try {
4903       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4904     } catch (std::out_of_range& e) {
4905       {
4906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4907       };
4908     } catch (std::exception& e) {
4909       {
4910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4911       };
4912     } catch (Dali::DaliException e) {
4913       {
4914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4915       };
4916     } catch (...) {
4917       {
4918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4919       };
4920     }
4921   }
4922
4923   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4924   return jresult;
4925 }
4926
4927
4928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4929   void * jresult ;
4930   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4931   Dali::Vector2 *arg2 = 0 ;
4932   Dali::Vector2 *result = 0 ;
4933
4934   arg1 = (Dali::Vector2 *)jarg1;
4935   arg2 = (Dali::Vector2 *)jarg2;
4936   if (!arg2) {
4937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4938     return 0;
4939   }
4940   {
4941     try {
4942       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4943     } catch (std::out_of_range& e) {
4944       {
4945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4946       };
4947     } catch (std::exception& e) {
4948       {
4949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4950       };
4951     } catch (Dali::DaliException e) {
4952       {
4953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4954       };
4955     } catch (...) {
4956       {
4957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4958       };
4959     }
4960   }
4961
4962   jresult = (void *)result;
4963   return jresult;
4964 }
4965
4966
4967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4968   void * jresult ;
4969   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4970   float arg2 ;
4971   Dali::Vector2 *result = 0 ;
4972
4973   arg1 = (Dali::Vector2 *)jarg1;
4974   arg2 = (float)jarg2;
4975   {
4976     try {
4977       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4978     } catch (std::out_of_range& e) {
4979       {
4980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4981       };
4982     } catch (std::exception& e) {
4983       {
4984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4985       };
4986     } catch (Dali::DaliException e) {
4987       {
4988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4989       };
4990     } catch (...) {
4991       {
4992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4993       };
4994     }
4995   }
4996
4997   jresult = (void *)result;
4998   return jresult;
4999 }
5000
5001
5002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5003   void * jresult ;
5004   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5005   Dali::Vector2 result;
5006
5007   arg1 = (Dali::Vector2 *)jarg1;
5008   {
5009     try {
5010       result = ((Dali::Vector2 const *)arg1)->operator -();
5011     } catch (std::out_of_range& e) {
5012       {
5013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5014       };
5015     } catch (std::exception& e) {
5016       {
5017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5018       };
5019     } catch (Dali::DaliException e) {
5020       {
5021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5022       };
5023     } catch (...) {
5024       {
5025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5026       };
5027     }
5028   }
5029
5030   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5031   return jresult;
5032 }
5033
5034
5035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5036   unsigned int jresult ;
5037   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5038   Dali::Vector2 *arg2 = 0 ;
5039   bool result;
5040
5041   arg1 = (Dali::Vector2 *)jarg1;
5042   arg2 = (Dali::Vector2 *)jarg2;
5043   if (!arg2) {
5044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5045     return 0;
5046   }
5047   {
5048     try {
5049       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5050     } catch (std::out_of_range& e) {
5051       {
5052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5053       };
5054     } catch (std::exception& e) {
5055       {
5056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5057       };
5058     } catch (Dali::DaliException e) {
5059       {
5060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5061       };
5062     } catch (...) {
5063       {
5064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5065       };
5066     }
5067   }
5068
5069   jresult = result;
5070   return jresult;
5071 }
5072
5073
5074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5075   unsigned int jresult ;
5076   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5077   Dali::Vector2 *arg2 = 0 ;
5078   bool result;
5079
5080   arg1 = (Dali::Vector2 *)jarg1;
5081   arg2 = (Dali::Vector2 *)jarg2;
5082   if (!arg2) {
5083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5084     return 0;
5085   }
5086   {
5087     try {
5088       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5089     } catch (std::out_of_range& e) {
5090       {
5091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5092       };
5093     } catch (std::exception& e) {
5094       {
5095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5096       };
5097     } catch (Dali::DaliException e) {
5098       {
5099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5100       };
5101     } catch (...) {
5102       {
5103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5104       };
5105     }
5106   }
5107
5108   jresult = result;
5109   return jresult;
5110 }
5111
5112
5113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5114   float jresult ;
5115   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5116   unsigned int arg2 ;
5117   float *result = 0 ;
5118
5119   arg1 = (Dali::Vector2 *)jarg1;
5120   arg2 = (unsigned int)jarg2;
5121   {
5122     try {
5123       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5124     } catch (std::out_of_range& e) {
5125       {
5126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5127       };
5128     } catch (std::exception& e) {
5129       {
5130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5131       };
5132     } catch (Dali::DaliException e) {
5133       {
5134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5135       };
5136     } catch (...) {
5137       {
5138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5139       };
5140     }
5141   }
5142
5143   jresult = *result;
5144   return jresult;
5145 }
5146
5147
5148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5149   float jresult ;
5150   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5151   float result;
5152
5153   arg1 = (Dali::Vector2 *)jarg1;
5154   {
5155     try {
5156       result = (float)((Dali::Vector2 const *)arg1)->Length();
5157     } catch (std::out_of_range& e) {
5158       {
5159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5160       };
5161     } catch (std::exception& e) {
5162       {
5163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5164       };
5165     } catch (Dali::DaliException e) {
5166       {
5167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5168       };
5169     } catch (...) {
5170       {
5171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5172       };
5173     }
5174   }
5175
5176   jresult = result;
5177   return jresult;
5178 }
5179
5180
5181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5182   float jresult ;
5183   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5184   float result;
5185
5186   arg1 = (Dali::Vector2 *)jarg1;
5187   {
5188     try {
5189       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5190     } catch (std::out_of_range& e) {
5191       {
5192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5193       };
5194     } catch (std::exception& e) {
5195       {
5196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5197       };
5198     } catch (Dali::DaliException e) {
5199       {
5200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5201       };
5202     } catch (...) {
5203       {
5204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5205       };
5206     }
5207   }
5208
5209   jresult = result;
5210   return jresult;
5211 }
5212
5213
5214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5215   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5216
5217   arg1 = (Dali::Vector2 *)jarg1;
5218   {
5219     try {
5220       (arg1)->Normalize();
5221     } catch (std::out_of_range& e) {
5222       {
5223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5224       };
5225     } catch (std::exception& e) {
5226       {
5227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5228       };
5229     } catch (Dali::DaliException e) {
5230       {
5231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5232       };
5233     } catch (...) {
5234       {
5235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5236       };
5237     }
5238   }
5239
5240 }
5241
5242
5243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5244   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5245   Dali::Vector2 *arg2 = 0 ;
5246   Dali::Vector2 *arg3 = 0 ;
5247
5248   arg1 = (Dali::Vector2 *)jarg1;
5249   arg2 = (Dali::Vector2 *)jarg2;
5250   if (!arg2) {
5251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5252     return ;
5253   }
5254   arg3 = (Dali::Vector2 *)jarg3;
5255   if (!arg3) {
5256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5257     return ;
5258   }
5259   {
5260     try {
5261       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5262     } catch (std::out_of_range& e) {
5263       {
5264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5265       };
5266     } catch (std::exception& e) {
5267       {
5268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5269       };
5270     } catch (Dali::DaliException e) {
5271       {
5272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5273       };
5274     } catch (...) {
5275       {
5276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5277       };
5278     }
5279   }
5280
5281 }
5282
5283
5284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5285   void * jresult ;
5286   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5287   float *result = 0 ;
5288
5289   arg1 = (Dali::Vector2 *)jarg1;
5290   {
5291     try {
5292       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5293     } catch (std::out_of_range& e) {
5294       {
5295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5296       };
5297     } catch (std::exception& e) {
5298       {
5299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5300       };
5301     } catch (Dali::DaliException e) {
5302       {
5303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5304       };
5305     } catch (...) {
5306       {
5307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5308       };
5309     }
5310   }
5311
5312   jresult = (void *)result;
5313   return jresult;
5314 }
5315
5316
5317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5318   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5319   float arg2 ;
5320
5321   arg1 = (Dali::Vector2 *)jarg1;
5322   arg2 = (float)jarg2;
5323   if (arg1) (arg1)->x = arg2;
5324 }
5325
5326
5327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5328   float jresult ;
5329   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5330   float result;
5331
5332   arg1 = (Dali::Vector2 *)jarg1;
5333   result = (float) ((arg1)->x);
5334   jresult = result;
5335   return jresult;
5336 }
5337
5338
5339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5340   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5341   float arg2 ;
5342
5343   arg1 = (Dali::Vector2 *)jarg1;
5344   arg2 = (float)jarg2;
5345   if (arg1) (arg1)->width = arg2;
5346 }
5347
5348
5349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5350   float jresult ;
5351   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5352   float result;
5353
5354   arg1 = (Dali::Vector2 *)jarg1;
5355   result = (float) ((arg1)->width);
5356   jresult = result;
5357   return jresult;
5358 }
5359
5360
5361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5362   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5363   float arg2 ;
5364
5365   arg1 = (Dali::Vector2 *)jarg1;
5366   arg2 = (float)jarg2;
5367   if (arg1) (arg1)->y = arg2;
5368 }
5369
5370
5371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5372   float jresult ;
5373   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5374   float result;
5375
5376   arg1 = (Dali::Vector2 *)jarg1;
5377   result = (float) ((arg1)->y);
5378   jresult = result;
5379   return jresult;
5380 }
5381
5382
5383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5384   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5385   float arg2 ;
5386
5387   arg1 = (Dali::Vector2 *)jarg1;
5388   arg2 = (float)jarg2;
5389   if (arg1) (arg1)->height = arg2;
5390 }
5391
5392
5393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5394   float jresult ;
5395   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5396   float result;
5397
5398   arg1 = (Dali::Vector2 *)jarg1;
5399   result = (float) ((arg1)->height);
5400   jresult = result;
5401   return jresult;
5402 }
5403
5404
5405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5406   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5407
5408   arg1 = (Dali::Vector2 *)jarg1;
5409   {
5410     try {
5411       delete arg1;
5412     } catch (std::out_of_range& e) {
5413       {
5414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5415       };
5416     } catch (std::exception& e) {
5417       {
5418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5419       };
5420     } catch (Dali::DaliException e) {
5421       {
5422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5423       };
5424     } catch (...) {
5425       {
5426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5427       };
5428     }
5429   }
5430
5431 }
5432
5433
5434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5435   void * jresult ;
5436   Dali::Vector2 *arg1 = 0 ;
5437   Dali::Vector2 *arg2 = 0 ;
5438   Dali::Vector2 result;
5439
5440   arg1 = (Dali::Vector2 *)jarg1;
5441   if (!arg1) {
5442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5443     return 0;
5444   }
5445   arg2 = (Dali::Vector2 *)jarg2;
5446   if (!arg2) {
5447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5448     return 0;
5449   }
5450   {
5451     try {
5452       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5453     } catch (std::out_of_range& e) {
5454       {
5455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5456       };
5457     } catch (std::exception& e) {
5458       {
5459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5460       };
5461     } catch (Dali::DaliException e) {
5462       {
5463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5464       };
5465     } catch (...) {
5466       {
5467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5468       };
5469     }
5470   }
5471
5472   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5473   return jresult;
5474 }
5475
5476
5477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5478   void * jresult ;
5479   Dali::Vector2 *arg1 = 0 ;
5480   Dali::Vector2 *arg2 = 0 ;
5481   Dali::Vector2 result;
5482
5483   arg1 = (Dali::Vector2 *)jarg1;
5484   if (!arg1) {
5485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5486     return 0;
5487   }
5488   arg2 = (Dali::Vector2 *)jarg2;
5489   if (!arg2) {
5490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5491     return 0;
5492   }
5493   {
5494     try {
5495       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5496     } catch (std::out_of_range& e) {
5497       {
5498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5499       };
5500     } catch (std::exception& e) {
5501       {
5502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5503       };
5504     } catch (Dali::DaliException e) {
5505       {
5506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5507       };
5508     } catch (...) {
5509       {
5510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5511       };
5512     }
5513   }
5514
5515   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5516   return jresult;
5517 }
5518
5519
5520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5521   void * jresult ;
5522   Dali::Vector2 *arg1 = 0 ;
5523   float *arg2 = 0 ;
5524   float *arg3 = 0 ;
5525   float temp2 ;
5526   float temp3 ;
5527   Dali::Vector2 result;
5528
5529   arg1 = (Dali::Vector2 *)jarg1;
5530   if (!arg1) {
5531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5532     return 0;
5533   }
5534   temp2 = (float)jarg2;
5535   arg2 = &temp2;
5536   temp3 = (float)jarg3;
5537   arg3 = &temp3;
5538   {
5539     try {
5540       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5541     } catch (std::out_of_range& e) {
5542       {
5543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5544       };
5545     } catch (std::exception& e) {
5546       {
5547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5548       };
5549     } catch (Dali::DaliException e) {
5550       {
5551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5552       };
5553     } catch (...) {
5554       {
5555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5556       };
5557     }
5558   }
5559
5560   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5561   return jresult;
5562 }
5563
5564
5565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5566   void * jresult ;
5567   Dali::Vector3 *result = 0 ;
5568
5569   {
5570     try {
5571       result = (Dali::Vector3 *)new Dali::Vector3();
5572     } catch (std::out_of_range& e) {
5573       {
5574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5575       };
5576     } catch (std::exception& e) {
5577       {
5578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5579       };
5580     } catch (Dali::DaliException e) {
5581       {
5582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5583       };
5584     } catch (...) {
5585       {
5586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5587       };
5588     }
5589   }
5590
5591   jresult = (void *)result;
5592   return jresult;
5593 }
5594
5595
5596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5597   void * jresult ;
5598   float arg1 ;
5599   float arg2 ;
5600   float arg3 ;
5601   Dali::Vector3 *result = 0 ;
5602
5603   arg1 = (float)jarg1;
5604   arg2 = (float)jarg2;
5605   arg3 = (float)jarg3;
5606   {
5607     try {
5608       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5609     } catch (std::out_of_range& e) {
5610       {
5611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5612       };
5613     } catch (std::exception& e) {
5614       {
5615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5616       };
5617     } catch (Dali::DaliException e) {
5618       {
5619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5620       };
5621     } catch (...) {
5622       {
5623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5624       };
5625     }
5626   }
5627
5628   jresult = (void *)result;
5629   return jresult;
5630 }
5631
5632
5633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5634   void * jresult ;
5635   float *arg1 = (float *) 0 ;
5636   Dali::Vector3 *result = 0 ;
5637
5638   arg1 = jarg1;
5639   {
5640     try {
5641       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5642     } catch (std::out_of_range& e) {
5643       {
5644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5645       };
5646     } catch (std::exception& e) {
5647       {
5648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5649       };
5650     } catch (Dali::DaliException e) {
5651       {
5652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5653       };
5654     } catch (...) {
5655       {
5656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5657       };
5658     }
5659   }
5660
5661   jresult = (void *)result;
5662
5663
5664   return jresult;
5665 }
5666
5667
5668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5669   void * jresult ;
5670   Dali::Vector2 *arg1 = 0 ;
5671   Dali::Vector3 *result = 0 ;
5672
5673   arg1 = (Dali::Vector2 *)jarg1;
5674   if (!arg1) {
5675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5676     return 0;
5677   }
5678   {
5679     try {
5680       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5681     } catch (std::out_of_range& e) {
5682       {
5683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5684       };
5685     } catch (std::exception& e) {
5686       {
5687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5688       };
5689     } catch (Dali::DaliException e) {
5690       {
5691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5692       };
5693     } catch (...) {
5694       {
5695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5696       };
5697     }
5698   }
5699
5700   jresult = (void *)result;
5701   return jresult;
5702 }
5703
5704
5705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5706   void * jresult ;
5707   Dali::Vector4 *arg1 = 0 ;
5708   Dali::Vector3 *result = 0 ;
5709
5710   arg1 = (Dali::Vector4 *)jarg1;
5711   if (!arg1) {
5712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5713     return 0;
5714   }
5715   {
5716     try {
5717       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5718     } catch (std::out_of_range& e) {
5719       {
5720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5721       };
5722     } catch (std::exception& e) {
5723       {
5724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5725       };
5726     } catch (Dali::DaliException e) {
5727       {
5728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5729       };
5730     } catch (...) {
5731       {
5732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5733       };
5734     }
5735   }
5736
5737   jresult = (void *)result;
5738   return jresult;
5739 }
5740
5741
5742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5743   void * jresult ;
5744   Dali::Vector3 *result = 0 ;
5745
5746   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5747   jresult = (void *)result;
5748   return jresult;
5749 }
5750
5751
5752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5753   void * jresult ;
5754   Dali::Vector3 *result = 0 ;
5755
5756   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5757   jresult = (void *)result;
5758   return jresult;
5759 }
5760
5761
5762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5763   void * jresult ;
5764   Dali::Vector3 *result = 0 ;
5765
5766   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5767   jresult = (void *)result;
5768   return jresult;
5769 }
5770
5771
5772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5773   void * jresult ;
5774   Dali::Vector3 *result = 0 ;
5775
5776   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5777   jresult = (void *)result;
5778   return jresult;
5779 }
5780
5781
5782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5783   void * jresult ;
5784   Dali::Vector3 *result = 0 ;
5785
5786   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5787   jresult = (void *)result;
5788   return jresult;
5789 }
5790
5791
5792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5793   void * jresult ;
5794   Dali::Vector3 *result = 0 ;
5795
5796   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5797   jresult = (void *)result;
5798   return jresult;
5799 }
5800
5801
5802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5803   void * jresult ;
5804   Dali::Vector3 *result = 0 ;
5805
5806   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5807   jresult = (void *)result;
5808   return jresult;
5809 }
5810
5811
5812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5813   void * jresult ;
5814   Dali::Vector3 *result = 0 ;
5815
5816   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5817   jresult = (void *)result;
5818   return jresult;
5819 }
5820
5821
5822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5823   void * jresult ;
5824   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5825   float *arg2 = (float *) 0 ;
5826   Dali::Vector3 *result = 0 ;
5827
5828   arg1 = (Dali::Vector3 *)jarg1;
5829   arg2 = jarg2;
5830   {
5831     try {
5832       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5833     } catch (std::out_of_range& e) {
5834       {
5835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5836       };
5837     } catch (std::exception& e) {
5838       {
5839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5840       };
5841     } catch (Dali::DaliException e) {
5842       {
5843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5844       };
5845     } catch (...) {
5846       {
5847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5848       };
5849     }
5850   }
5851
5852   jresult = (void *)result;
5853
5854
5855   return jresult;
5856 }
5857
5858
5859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5860   void * jresult ;
5861   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5862   Dali::Vector2 *arg2 = 0 ;
5863   Dali::Vector3 *result = 0 ;
5864
5865   arg1 = (Dali::Vector3 *)jarg1;
5866   arg2 = (Dali::Vector2 *)jarg2;
5867   if (!arg2) {
5868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5869     return 0;
5870   }
5871   {
5872     try {
5873       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5874     } catch (std::out_of_range& e) {
5875       {
5876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5877       };
5878     } catch (std::exception& e) {
5879       {
5880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5881       };
5882     } catch (Dali::DaliException e) {
5883       {
5884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5885       };
5886     } catch (...) {
5887       {
5888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5889       };
5890     }
5891   }
5892
5893   jresult = (void *)result;
5894   return jresult;
5895 }
5896
5897
5898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5899   void * jresult ;
5900   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5901   Dali::Vector4 *arg2 = 0 ;
5902   Dali::Vector3 *result = 0 ;
5903
5904   arg1 = (Dali::Vector3 *)jarg1;
5905   arg2 = (Dali::Vector4 *)jarg2;
5906   if (!arg2) {
5907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5908     return 0;
5909   }
5910   {
5911     try {
5912       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5913     } catch (std::out_of_range& e) {
5914       {
5915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5916       };
5917     } catch (std::exception& e) {
5918       {
5919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5920       };
5921     } catch (Dali::DaliException e) {
5922       {
5923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5924       };
5925     } catch (...) {
5926       {
5927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5928       };
5929     }
5930   }
5931
5932   jresult = (void *)result;
5933   return jresult;
5934 }
5935
5936
5937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5938   void * jresult ;
5939   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5940   Dali::Vector3 *arg2 = 0 ;
5941   Dali::Vector3 result;
5942
5943   arg1 = (Dali::Vector3 *)jarg1;
5944   arg2 = (Dali::Vector3 *)jarg2;
5945   if (!arg2) {
5946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5947     return 0;
5948   }
5949   {
5950     try {
5951       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5952     } catch (std::out_of_range& e) {
5953       {
5954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5955       };
5956     } catch (std::exception& e) {
5957       {
5958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5959       };
5960     } catch (Dali::DaliException e) {
5961       {
5962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5963       };
5964     } catch (...) {
5965       {
5966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5967       };
5968     }
5969   }
5970
5971   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5972   return jresult;
5973 }
5974
5975
5976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5977   void * jresult ;
5978   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5979   Dali::Vector3 *arg2 = 0 ;
5980   Dali::Vector3 *result = 0 ;
5981
5982   arg1 = (Dali::Vector3 *)jarg1;
5983   arg2 = (Dali::Vector3 *)jarg2;
5984   if (!arg2) {
5985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5986     return 0;
5987   }
5988   {
5989     try {
5990       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5991     } catch (std::out_of_range& e) {
5992       {
5993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5994       };
5995     } catch (std::exception& e) {
5996       {
5997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5998       };
5999     } catch (Dali::DaliException e) {
6000       {
6001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6002       };
6003     } catch (...) {
6004       {
6005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6006       };
6007     }
6008   }
6009
6010   jresult = (void *)result;
6011   return jresult;
6012 }
6013
6014
6015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6016   void * jresult ;
6017   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6018   Dali::Vector3 *arg2 = 0 ;
6019   Dali::Vector3 result;
6020
6021   arg1 = (Dali::Vector3 *)jarg1;
6022   arg2 = (Dali::Vector3 *)jarg2;
6023   if (!arg2) {
6024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6025     return 0;
6026   }
6027   {
6028     try {
6029       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6030     } catch (std::out_of_range& e) {
6031       {
6032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6033       };
6034     } catch (std::exception& e) {
6035       {
6036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6037       };
6038     } catch (Dali::DaliException e) {
6039       {
6040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6041       };
6042     } catch (...) {
6043       {
6044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6045       };
6046     }
6047   }
6048
6049   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6050   return jresult;
6051 }
6052
6053
6054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6055   void * jresult ;
6056   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6057   Dali::Vector3 *arg2 = 0 ;
6058   Dali::Vector3 *result = 0 ;
6059
6060   arg1 = (Dali::Vector3 *)jarg1;
6061   arg2 = (Dali::Vector3 *)jarg2;
6062   if (!arg2) {
6063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6064     return 0;
6065   }
6066   {
6067     try {
6068       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6069     } catch (std::out_of_range& e) {
6070       {
6071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6072       };
6073     } catch (std::exception& e) {
6074       {
6075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6076       };
6077     } catch (Dali::DaliException e) {
6078       {
6079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6080       };
6081     } catch (...) {
6082       {
6083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6084       };
6085     }
6086   }
6087
6088   jresult = (void *)result;
6089   return jresult;
6090 }
6091
6092
6093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6094   void * jresult ;
6095   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6096   Dali::Vector3 *arg2 = 0 ;
6097   Dali::Vector3 result;
6098
6099   arg1 = (Dali::Vector3 *)jarg1;
6100   arg2 = (Dali::Vector3 *)jarg2;
6101   if (!arg2) {
6102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6103     return 0;
6104   }
6105   {
6106     try {
6107       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6108     } catch (std::out_of_range& e) {
6109       {
6110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6111       };
6112     } catch (std::exception& e) {
6113       {
6114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6115       };
6116     } catch (Dali::DaliException e) {
6117       {
6118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6119       };
6120     } catch (...) {
6121       {
6122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6123       };
6124     }
6125   }
6126
6127   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6128   return jresult;
6129 }
6130
6131
6132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6133   void * jresult ;
6134   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6135   float arg2 ;
6136   Dali::Vector3 result;
6137
6138   arg1 = (Dali::Vector3 *)jarg1;
6139   arg2 = (float)jarg2;
6140   {
6141     try {
6142       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6143     } catch (std::out_of_range& e) {
6144       {
6145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6146       };
6147     } catch (std::exception& e) {
6148       {
6149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6150       };
6151     } catch (Dali::DaliException e) {
6152       {
6153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6154       };
6155     } catch (...) {
6156       {
6157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6158       };
6159     }
6160   }
6161
6162   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6163   return jresult;
6164 }
6165
6166
6167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6168   void * jresult ;
6169   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6170   Dali::Vector3 *arg2 = 0 ;
6171   Dali::Vector3 *result = 0 ;
6172
6173   arg1 = (Dali::Vector3 *)jarg1;
6174   arg2 = (Dali::Vector3 *)jarg2;
6175   if (!arg2) {
6176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6177     return 0;
6178   }
6179   {
6180     try {
6181       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6182     } catch (std::out_of_range& e) {
6183       {
6184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6185       };
6186     } catch (std::exception& e) {
6187       {
6188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6189       };
6190     } catch (Dali::DaliException e) {
6191       {
6192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6193       };
6194     } catch (...) {
6195       {
6196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6197       };
6198     }
6199   }
6200
6201   jresult = (void *)result;
6202   return jresult;
6203 }
6204
6205
6206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6207   void * jresult ;
6208   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6209   float arg2 ;
6210   Dali::Vector3 *result = 0 ;
6211
6212   arg1 = (Dali::Vector3 *)jarg1;
6213   arg2 = (float)jarg2;
6214   {
6215     try {
6216       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6217     } catch (std::out_of_range& e) {
6218       {
6219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6220       };
6221     } catch (std::exception& e) {
6222       {
6223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6224       };
6225     } catch (Dali::DaliException e) {
6226       {
6227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6228       };
6229     } catch (...) {
6230       {
6231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6232       };
6233     }
6234   }
6235
6236   jresult = (void *)result;
6237   return jresult;
6238 }
6239
6240
6241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6242   void * jresult ;
6243   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6244   Dali::Quaternion *arg2 = 0 ;
6245   Dali::Vector3 *result = 0 ;
6246
6247   arg1 = (Dali::Vector3 *)jarg1;
6248   arg2 = (Dali::Quaternion *)jarg2;
6249   if (!arg2) {
6250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6251     return 0;
6252   }
6253   {
6254     try {
6255       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6256     } catch (std::out_of_range& e) {
6257       {
6258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6259       };
6260     } catch (std::exception& e) {
6261       {
6262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6263       };
6264     } catch (Dali::DaliException e) {
6265       {
6266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6267       };
6268     } catch (...) {
6269       {
6270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6271       };
6272     }
6273   }
6274
6275   jresult = (void *)result;
6276   return jresult;
6277 }
6278
6279
6280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6281   void * jresult ;
6282   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6283   Dali::Vector3 *arg2 = 0 ;
6284   Dali::Vector3 result;
6285
6286   arg1 = (Dali::Vector3 *)jarg1;
6287   arg2 = (Dali::Vector3 *)jarg2;
6288   if (!arg2) {
6289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6290     return 0;
6291   }
6292   {
6293     try {
6294       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6295     } catch (std::out_of_range& e) {
6296       {
6297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6298       };
6299     } catch (std::exception& e) {
6300       {
6301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6302       };
6303     } catch (Dali::DaliException e) {
6304       {
6305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6306       };
6307     } catch (...) {
6308       {
6309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6310       };
6311     }
6312   }
6313
6314   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6315   return jresult;
6316 }
6317
6318
6319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6320   void * jresult ;
6321   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6322   float arg2 ;
6323   Dali::Vector3 result;
6324
6325   arg1 = (Dali::Vector3 *)jarg1;
6326   arg2 = (float)jarg2;
6327   {
6328     try {
6329       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6330     } catch (std::out_of_range& e) {
6331       {
6332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6333       };
6334     } catch (std::exception& e) {
6335       {
6336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6337       };
6338     } catch (Dali::DaliException e) {
6339       {
6340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6341       };
6342     } catch (...) {
6343       {
6344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6345       };
6346     }
6347   }
6348
6349   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6350   return jresult;
6351 }
6352
6353
6354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6355   void * jresult ;
6356   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6357   Dali::Vector3 *arg2 = 0 ;
6358   Dali::Vector3 *result = 0 ;
6359
6360   arg1 = (Dali::Vector3 *)jarg1;
6361   arg2 = (Dali::Vector3 *)jarg2;
6362   if (!arg2) {
6363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6364     return 0;
6365   }
6366   {
6367     try {
6368       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6369     } catch (std::out_of_range& e) {
6370       {
6371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6372       };
6373     } catch (std::exception& e) {
6374       {
6375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6376       };
6377     } catch (Dali::DaliException e) {
6378       {
6379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6380       };
6381     } catch (...) {
6382       {
6383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6384       };
6385     }
6386   }
6387
6388   jresult = (void *)result;
6389   return jresult;
6390 }
6391
6392
6393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6394   void * jresult ;
6395   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6396   float arg2 ;
6397   Dali::Vector3 *result = 0 ;
6398
6399   arg1 = (Dali::Vector3 *)jarg1;
6400   arg2 = (float)jarg2;
6401   {
6402     try {
6403       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6404     } catch (std::out_of_range& e) {
6405       {
6406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6407       };
6408     } catch (std::exception& e) {
6409       {
6410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6411       };
6412     } catch (Dali::DaliException e) {
6413       {
6414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6415       };
6416     } catch (...) {
6417       {
6418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6419       };
6420     }
6421   }
6422
6423   jresult = (void *)result;
6424   return jresult;
6425 }
6426
6427
6428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6429   void * jresult ;
6430   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6431   Dali::Vector3 result;
6432
6433   arg1 = (Dali::Vector3 *)jarg1;
6434   {
6435     try {
6436       result = ((Dali::Vector3 const *)arg1)->operator -();
6437     } catch (std::out_of_range& e) {
6438       {
6439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6440       };
6441     } catch (std::exception& e) {
6442       {
6443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6444       };
6445     } catch (Dali::DaliException e) {
6446       {
6447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6448       };
6449     } catch (...) {
6450       {
6451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6452       };
6453     }
6454   }
6455
6456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6457   return jresult;
6458 }
6459
6460
6461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6462   unsigned int jresult ;
6463   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6464   Dali::Vector3 *arg2 = 0 ;
6465   bool result;
6466
6467   arg1 = (Dali::Vector3 *)jarg1;
6468   arg2 = (Dali::Vector3 *)jarg2;
6469   if (!arg2) {
6470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6471     return 0;
6472   }
6473   {
6474     try {
6475       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6476     } catch (std::out_of_range& e) {
6477       {
6478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6479       };
6480     } catch (std::exception& e) {
6481       {
6482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6483       };
6484     } catch (Dali::DaliException e) {
6485       {
6486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6487       };
6488     } catch (...) {
6489       {
6490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6491       };
6492     }
6493   }
6494
6495   jresult = result;
6496   return jresult;
6497 }
6498
6499
6500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6501   unsigned int jresult ;
6502   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6503   Dali::Vector3 *arg2 = 0 ;
6504   bool result;
6505
6506   arg1 = (Dali::Vector3 *)jarg1;
6507   arg2 = (Dali::Vector3 *)jarg2;
6508   if (!arg2) {
6509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6510     return 0;
6511   }
6512   {
6513     try {
6514       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6515     } catch (std::out_of_range& e) {
6516       {
6517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6518       };
6519     } catch (std::exception& e) {
6520       {
6521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6522       };
6523     } catch (Dali::DaliException e) {
6524       {
6525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6526       };
6527     } catch (...) {
6528       {
6529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6530       };
6531     }
6532   }
6533
6534   jresult = result;
6535   return jresult;
6536 }
6537
6538
6539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6540   float jresult ;
6541   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6542   unsigned int arg2 ;
6543   float *result = 0 ;
6544
6545   arg1 = (Dali::Vector3 *)jarg1;
6546   arg2 = (unsigned int)jarg2;
6547   {
6548     try {
6549       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6550     } catch (std::out_of_range& e) {
6551       {
6552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6553       };
6554     } catch (std::exception& e) {
6555       {
6556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6557       };
6558     } catch (Dali::DaliException e) {
6559       {
6560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6561       };
6562     } catch (...) {
6563       {
6564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6565       };
6566     }
6567   }
6568
6569   jresult = *result;
6570   return jresult;
6571 }
6572
6573
6574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6575   float jresult ;
6576   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6577   Dali::Vector3 *arg2 = 0 ;
6578   float result;
6579
6580   arg1 = (Dali::Vector3 *)jarg1;
6581   arg2 = (Dali::Vector3 *)jarg2;
6582   if (!arg2) {
6583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6584     return 0;
6585   }
6586   {
6587     try {
6588       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6589     } catch (std::out_of_range& e) {
6590       {
6591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6592       };
6593     } catch (std::exception& e) {
6594       {
6595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6596       };
6597     } catch (Dali::DaliException e) {
6598       {
6599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6600       };
6601     } catch (...) {
6602       {
6603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6604       };
6605     }
6606   }
6607
6608   jresult = result;
6609   return jresult;
6610 }
6611
6612
6613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6614   void * jresult ;
6615   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6616   Dali::Vector3 *arg2 = 0 ;
6617   Dali::Vector3 result;
6618
6619   arg1 = (Dali::Vector3 *)jarg1;
6620   arg2 = (Dali::Vector3 *)jarg2;
6621   if (!arg2) {
6622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6623     return 0;
6624   }
6625   {
6626     try {
6627       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6628     } catch (std::out_of_range& e) {
6629       {
6630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6631       };
6632     } catch (std::exception& e) {
6633       {
6634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6635       };
6636     } catch (Dali::DaliException e) {
6637       {
6638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6639       };
6640     } catch (...) {
6641       {
6642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6643       };
6644     }
6645   }
6646
6647   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6648   return jresult;
6649 }
6650
6651
6652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6653   float jresult ;
6654   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6655   float result;
6656
6657   arg1 = (Dali::Vector3 *)jarg1;
6658   {
6659     try {
6660       result = (float)((Dali::Vector3 const *)arg1)->Length();
6661     } catch (std::out_of_range& e) {
6662       {
6663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6664       };
6665     } catch (std::exception& e) {
6666       {
6667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6668       };
6669     } catch (Dali::DaliException e) {
6670       {
6671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6672       };
6673     } catch (...) {
6674       {
6675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6676       };
6677     }
6678   }
6679
6680   jresult = result;
6681   return jresult;
6682 }
6683
6684
6685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6686   float jresult ;
6687   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6688   float result;
6689
6690   arg1 = (Dali::Vector3 *)jarg1;
6691   {
6692     try {
6693       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6694     } catch (std::out_of_range& e) {
6695       {
6696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6697       };
6698     } catch (std::exception& e) {
6699       {
6700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6701       };
6702     } catch (Dali::DaliException e) {
6703       {
6704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6705       };
6706     } catch (...) {
6707       {
6708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6709       };
6710     }
6711   }
6712
6713   jresult = result;
6714   return jresult;
6715 }
6716
6717
6718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6719   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6720
6721   arg1 = (Dali::Vector3 *)jarg1;
6722   {
6723     try {
6724       (arg1)->Normalize();
6725     } catch (std::out_of_range& e) {
6726       {
6727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6728       };
6729     } catch (std::exception& e) {
6730       {
6731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6732       };
6733     } catch (Dali::DaliException e) {
6734       {
6735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6736       };
6737     } catch (...) {
6738       {
6739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6740       };
6741     }
6742   }
6743
6744 }
6745
6746
6747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6748   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6749   Dali::Vector3 *arg2 = 0 ;
6750   Dali::Vector3 *arg3 = 0 ;
6751
6752   arg1 = (Dali::Vector3 *)jarg1;
6753   arg2 = (Dali::Vector3 *)jarg2;
6754   if (!arg2) {
6755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6756     return ;
6757   }
6758   arg3 = (Dali::Vector3 *)jarg3;
6759   if (!arg3) {
6760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6761     return ;
6762   }
6763   {
6764     try {
6765       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6766     } catch (std::out_of_range& e) {
6767       {
6768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6769       };
6770     } catch (std::exception& e) {
6771       {
6772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6773       };
6774     } catch (Dali::DaliException e) {
6775       {
6776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6777       };
6778     } catch (...) {
6779       {
6780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6781       };
6782     }
6783   }
6784
6785 }
6786
6787
6788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6789   void * jresult ;
6790   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6791   float *result = 0 ;
6792
6793   arg1 = (Dali::Vector3 *)jarg1;
6794   {
6795     try {
6796       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6797     } catch (std::out_of_range& e) {
6798       {
6799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6800       };
6801     } catch (std::exception& e) {
6802       {
6803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6804       };
6805     } catch (Dali::DaliException e) {
6806       {
6807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6808       };
6809     } catch (...) {
6810       {
6811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6812       };
6813     }
6814   }
6815
6816   jresult = (void *)result;
6817   return jresult;
6818 }
6819
6820
6821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6822   void * jresult ;
6823   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6824   Dali::Vector2 *result = 0 ;
6825
6826   arg1 = (Dali::Vector3 *)jarg1;
6827   {
6828     try {
6829       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6830     } catch (std::out_of_range& e) {
6831       {
6832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6833       };
6834     } catch (std::exception& e) {
6835       {
6836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6837       };
6838     } catch (Dali::DaliException e) {
6839       {
6840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6841       };
6842     } catch (...) {
6843       {
6844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6845       };
6846     }
6847   }
6848
6849   jresult = (void *)result;
6850   return jresult;
6851 }
6852
6853
6854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6855   void * jresult ;
6856   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6857   Dali::Vector2 *result = 0 ;
6858
6859   arg1 = (Dali::Vector3 *)jarg1;
6860   {
6861     try {
6862       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6863     } catch (std::out_of_range& e) {
6864       {
6865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6866       };
6867     } catch (std::exception& e) {
6868       {
6869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6870       };
6871     } catch (Dali::DaliException e) {
6872       {
6873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6874       };
6875     } catch (...) {
6876       {
6877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6878       };
6879     }
6880   }
6881
6882   jresult = (void *)result;
6883   return jresult;
6884 }
6885
6886
6887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6888   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6889   float arg2 ;
6890
6891   arg1 = (Dali::Vector3 *)jarg1;
6892   arg2 = (float)jarg2;
6893   if (arg1) (arg1)->x = arg2;
6894 }
6895
6896
6897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6898   float jresult ;
6899   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6900   float result;
6901
6902   arg1 = (Dali::Vector3 *)jarg1;
6903   result = (float) ((arg1)->x);
6904   jresult = result;
6905   return jresult;
6906 }
6907
6908
6909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6910   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6911   float arg2 ;
6912
6913   arg1 = (Dali::Vector3 *)jarg1;
6914   arg2 = (float)jarg2;
6915   if (arg1) (arg1)->width = arg2;
6916 }
6917
6918
6919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6920   float jresult ;
6921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6922   float result;
6923
6924   arg1 = (Dali::Vector3 *)jarg1;
6925   result = (float) ((arg1)->width);
6926   jresult = result;
6927   return jresult;
6928 }
6929
6930
6931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6932   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6933   float arg2 ;
6934
6935   arg1 = (Dali::Vector3 *)jarg1;
6936   arg2 = (float)jarg2;
6937   if (arg1) (arg1)->r = arg2;
6938 }
6939
6940
6941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6942   float jresult ;
6943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6944   float result;
6945
6946   arg1 = (Dali::Vector3 *)jarg1;
6947   result = (float) ((arg1)->r);
6948   jresult = result;
6949   return jresult;
6950 }
6951
6952
6953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6954   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6955   float arg2 ;
6956
6957   arg1 = (Dali::Vector3 *)jarg1;
6958   arg2 = (float)jarg2;
6959   if (arg1) (arg1)->y = arg2;
6960 }
6961
6962
6963 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6964   float jresult ;
6965   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6966   float result;
6967
6968   arg1 = (Dali::Vector3 *)jarg1;
6969   result = (float) ((arg1)->y);
6970   jresult = result;
6971   return jresult;
6972 }
6973
6974
6975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6976   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6977   float arg2 ;
6978
6979   arg1 = (Dali::Vector3 *)jarg1;
6980   arg2 = (float)jarg2;
6981   if (arg1) (arg1)->height = arg2;
6982 }
6983
6984
6985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6986   float jresult ;
6987   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6988   float result;
6989
6990   arg1 = (Dali::Vector3 *)jarg1;
6991   result = (float) ((arg1)->height);
6992   jresult = result;
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6998   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6999   float arg2 ;
7000
7001   arg1 = (Dali::Vector3 *)jarg1;
7002   arg2 = (float)jarg2;
7003   if (arg1) (arg1)->g = arg2;
7004 }
7005
7006
7007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7008   float jresult ;
7009   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7010   float result;
7011
7012   arg1 = (Dali::Vector3 *)jarg1;
7013   result = (float) ((arg1)->g);
7014   jresult = result;
7015   return jresult;
7016 }
7017
7018
7019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7020   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7021   float arg2 ;
7022
7023   arg1 = (Dali::Vector3 *)jarg1;
7024   arg2 = (float)jarg2;
7025   if (arg1) (arg1)->z = arg2;
7026 }
7027
7028
7029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7030   float jresult ;
7031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7032   float result;
7033
7034   arg1 = (Dali::Vector3 *)jarg1;
7035   result = (float) ((arg1)->z);
7036   jresult = result;
7037   return jresult;
7038 }
7039
7040
7041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7042   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7043   float arg2 ;
7044
7045   arg1 = (Dali::Vector3 *)jarg1;
7046   arg2 = (float)jarg2;
7047   if (arg1) (arg1)->depth = arg2;
7048 }
7049
7050
7051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7052   float jresult ;
7053   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7054   float result;
7055
7056   arg1 = (Dali::Vector3 *)jarg1;
7057   result = (float) ((arg1)->depth);
7058   jresult = result;
7059   return jresult;
7060 }
7061
7062
7063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7064   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7065   float arg2 ;
7066
7067   arg1 = (Dali::Vector3 *)jarg1;
7068   arg2 = (float)jarg2;
7069   if (arg1) (arg1)->b = arg2;
7070 }
7071
7072
7073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7074   float jresult ;
7075   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7076   float result;
7077
7078   arg1 = (Dali::Vector3 *)jarg1;
7079   result = (float) ((arg1)->b);
7080   jresult = result;
7081   return jresult;
7082 }
7083
7084
7085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7086   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7087
7088   arg1 = (Dali::Vector3 *)jarg1;
7089   {
7090     try {
7091       delete arg1;
7092     } catch (std::out_of_range& e) {
7093       {
7094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7095       };
7096     } catch (std::exception& e) {
7097       {
7098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7099       };
7100     } catch (Dali::DaliException e) {
7101       {
7102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7103       };
7104     } catch (...) {
7105       {
7106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7107       };
7108     }
7109   }
7110
7111 }
7112
7113
7114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7115   void * jresult ;
7116   Dali::Vector3 *arg1 = 0 ;
7117   Dali::Vector3 *arg2 = 0 ;
7118   Dali::Vector3 result;
7119
7120   arg1 = (Dali::Vector3 *)jarg1;
7121   if (!arg1) {
7122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7123     return 0;
7124   }
7125   arg2 = (Dali::Vector3 *)jarg2;
7126   if (!arg2) {
7127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7128     return 0;
7129   }
7130   {
7131     try {
7132       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7133     } catch (std::out_of_range& e) {
7134       {
7135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7136       };
7137     } catch (std::exception& e) {
7138       {
7139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7140       };
7141     } catch (Dali::DaliException e) {
7142       {
7143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7144       };
7145     } catch (...) {
7146       {
7147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7148       };
7149     }
7150   }
7151
7152   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7153   return jresult;
7154 }
7155
7156
7157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7158   void * jresult ;
7159   Dali::Vector3 *arg1 = 0 ;
7160   Dali::Vector3 *arg2 = 0 ;
7161   Dali::Vector3 result;
7162
7163   arg1 = (Dali::Vector3 *)jarg1;
7164   if (!arg1) {
7165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7166     return 0;
7167   }
7168   arg2 = (Dali::Vector3 *)jarg2;
7169   if (!arg2) {
7170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7171     return 0;
7172   }
7173   {
7174     try {
7175       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7176     } catch (std::out_of_range& e) {
7177       {
7178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7179       };
7180     } catch (std::exception& e) {
7181       {
7182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7183       };
7184     } catch (Dali::DaliException e) {
7185       {
7186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7187       };
7188     } catch (...) {
7189       {
7190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7191       };
7192     }
7193   }
7194
7195   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7196   return jresult;
7197 }
7198
7199
7200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7201   void * jresult ;
7202   Dali::Vector3 *arg1 = 0 ;
7203   float *arg2 = 0 ;
7204   float *arg3 = 0 ;
7205   float temp2 ;
7206   float temp3 ;
7207   Dali::Vector3 result;
7208
7209   arg1 = (Dali::Vector3 *)jarg1;
7210   if (!arg1) {
7211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7212     return 0;
7213   }
7214   temp2 = (float)jarg2;
7215   arg2 = &temp2;
7216   temp3 = (float)jarg3;
7217   arg3 = &temp3;
7218   {
7219     try {
7220       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7221     } catch (std::out_of_range& e) {
7222       {
7223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7224       };
7225     } catch (std::exception& e) {
7226       {
7227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7228       };
7229     } catch (Dali::DaliException e) {
7230       {
7231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7232       };
7233     } catch (...) {
7234       {
7235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7236       };
7237     }
7238   }
7239
7240   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7241   return jresult;
7242 }
7243
7244
7245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7246   void * jresult ;
7247   Dali::Vector4 *result = 0 ;
7248
7249   {
7250     try {
7251       result = (Dali::Vector4 *)new Dali::Vector4();
7252     } catch (std::out_of_range& e) {
7253       {
7254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7255       };
7256     } catch (std::exception& e) {
7257       {
7258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7259       };
7260     } catch (Dali::DaliException e) {
7261       {
7262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7263       };
7264     } catch (...) {
7265       {
7266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7267       };
7268     }
7269   }
7270
7271   jresult = (void *)result;
7272   return jresult;
7273 }
7274
7275
7276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7277   void * jresult ;
7278   float arg1 ;
7279   float arg2 ;
7280   float arg3 ;
7281   float arg4 ;
7282   Dali::Vector4 *result = 0 ;
7283
7284   arg1 = (float)jarg1;
7285   arg2 = (float)jarg2;
7286   arg3 = (float)jarg3;
7287   arg4 = (float)jarg4;
7288   {
7289     try {
7290       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7291     } catch (std::out_of_range& e) {
7292       {
7293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7294       };
7295     } catch (std::exception& e) {
7296       {
7297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7298       };
7299     } catch (Dali::DaliException e) {
7300       {
7301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7302       };
7303     } catch (...) {
7304       {
7305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7306       };
7307     }
7308   }
7309
7310   jresult = (void *)result;
7311   return jresult;
7312 }
7313
7314
7315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7316   void * jresult ;
7317   float *arg1 = (float *) 0 ;
7318   Dali::Vector4 *result = 0 ;
7319
7320   arg1 = jarg1;
7321   {
7322     try {
7323       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7324     } catch (std::out_of_range& e) {
7325       {
7326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7327       };
7328     } catch (std::exception& e) {
7329       {
7330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7331       };
7332     } catch (Dali::DaliException e) {
7333       {
7334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7335       };
7336     } catch (...) {
7337       {
7338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7339       };
7340     }
7341   }
7342
7343   jresult = (void *)result;
7344
7345
7346   return jresult;
7347 }
7348
7349
7350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7351   void * jresult ;
7352   Dali::Vector2 *arg1 = 0 ;
7353   Dali::Vector4 *result = 0 ;
7354
7355   arg1 = (Dali::Vector2 *)jarg1;
7356   if (!arg1) {
7357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7358     return 0;
7359   }
7360   {
7361     try {
7362       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7363     } catch (std::out_of_range& e) {
7364       {
7365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7366       };
7367     } catch (std::exception& e) {
7368       {
7369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7370       };
7371     } catch (Dali::DaliException e) {
7372       {
7373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7374       };
7375     } catch (...) {
7376       {
7377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7378       };
7379     }
7380   }
7381
7382   jresult = (void *)result;
7383   return jresult;
7384 }
7385
7386
7387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7388   void * jresult ;
7389   Dali::Vector3 *arg1 = 0 ;
7390   Dali::Vector4 *result = 0 ;
7391
7392   arg1 = (Dali::Vector3 *)jarg1;
7393   if (!arg1) {
7394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7395     return 0;
7396   }
7397   {
7398     try {
7399       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7400     } catch (std::out_of_range& e) {
7401       {
7402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7403       };
7404     } catch (std::exception& e) {
7405       {
7406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7407       };
7408     } catch (Dali::DaliException e) {
7409       {
7410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7411       };
7412     } catch (...) {
7413       {
7414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7415       };
7416     }
7417   }
7418
7419   jresult = (void *)result;
7420   return jresult;
7421 }
7422
7423
7424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7425   void * jresult ;
7426   Dali::Vector4 *result = 0 ;
7427
7428   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7429   jresult = (void *)result;
7430   return jresult;
7431 }
7432
7433
7434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7435   void * jresult ;
7436   Dali::Vector4 *result = 0 ;
7437
7438   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7439   jresult = (void *)result;
7440   return jresult;
7441 }
7442
7443
7444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7445   void * jresult ;
7446   Dali::Vector4 *result = 0 ;
7447
7448   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7449   jresult = (void *)result;
7450   return jresult;
7451 }
7452
7453
7454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7455   void * jresult ;
7456   Dali::Vector4 *result = 0 ;
7457
7458   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7459   jresult = (void *)result;
7460   return jresult;
7461 }
7462
7463
7464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7465   void * jresult ;
7466   Dali::Vector4 *result = 0 ;
7467
7468   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7469   jresult = (void *)result;
7470   return jresult;
7471 }
7472
7473
7474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7475   void * jresult ;
7476   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7477   float *arg2 = (float *) 0 ;
7478   Dali::Vector4 *result = 0 ;
7479
7480   arg1 = (Dali::Vector4 *)jarg1;
7481   arg2 = jarg2;
7482   {
7483     try {
7484       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7485     } catch (std::out_of_range& e) {
7486       {
7487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7488       };
7489     } catch (std::exception& e) {
7490       {
7491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7492       };
7493     } catch (Dali::DaliException e) {
7494       {
7495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7496       };
7497     } catch (...) {
7498       {
7499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7500       };
7501     }
7502   }
7503
7504   jresult = (void *)result;
7505
7506
7507   return jresult;
7508 }
7509
7510
7511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7512   void * jresult ;
7513   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7514   Dali::Vector2 *arg2 = 0 ;
7515   Dali::Vector4 *result = 0 ;
7516
7517   arg1 = (Dali::Vector4 *)jarg1;
7518   arg2 = (Dali::Vector2 *)jarg2;
7519   if (!arg2) {
7520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7521     return 0;
7522   }
7523   {
7524     try {
7525       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7526     } catch (std::out_of_range& e) {
7527       {
7528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7529       };
7530     } catch (std::exception& e) {
7531       {
7532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7533       };
7534     } catch (Dali::DaliException e) {
7535       {
7536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7537       };
7538     } catch (...) {
7539       {
7540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7541       };
7542     }
7543   }
7544
7545   jresult = (void *)result;
7546   return jresult;
7547 }
7548
7549
7550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7551   void * jresult ;
7552   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7553   Dali::Vector3 *arg2 = 0 ;
7554   Dali::Vector4 *result = 0 ;
7555
7556   arg1 = (Dali::Vector4 *)jarg1;
7557   arg2 = (Dali::Vector3 *)jarg2;
7558   if (!arg2) {
7559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7560     return 0;
7561   }
7562   {
7563     try {
7564       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7565     } catch (std::out_of_range& e) {
7566       {
7567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7568       };
7569     } catch (std::exception& e) {
7570       {
7571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7572       };
7573     } catch (Dali::DaliException e) {
7574       {
7575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7576       };
7577     } catch (...) {
7578       {
7579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7580       };
7581     }
7582   }
7583
7584   jresult = (void *)result;
7585   return jresult;
7586 }
7587
7588
7589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7590   void * jresult ;
7591   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7592   Dali::Vector4 *arg2 = 0 ;
7593   Dali::Vector4 result;
7594
7595   arg1 = (Dali::Vector4 *)jarg1;
7596   arg2 = (Dali::Vector4 *)jarg2;
7597   if (!arg2) {
7598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7599     return 0;
7600   }
7601   {
7602     try {
7603       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7604     } catch (std::out_of_range& e) {
7605       {
7606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7607       };
7608     } catch (std::exception& e) {
7609       {
7610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7611       };
7612     } catch (Dali::DaliException e) {
7613       {
7614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7615       };
7616     } catch (...) {
7617       {
7618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7619       };
7620     }
7621   }
7622
7623   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7624   return jresult;
7625 }
7626
7627
7628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7629   void * jresult ;
7630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7631   Dali::Vector4 *arg2 = 0 ;
7632   Dali::Vector4 *result = 0 ;
7633
7634   arg1 = (Dali::Vector4 *)jarg1;
7635   arg2 = (Dali::Vector4 *)jarg2;
7636   if (!arg2) {
7637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7638     return 0;
7639   }
7640   {
7641     try {
7642       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7643     } catch (std::out_of_range& e) {
7644       {
7645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7646       };
7647     } catch (std::exception& e) {
7648       {
7649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7650       };
7651     } catch (Dali::DaliException e) {
7652       {
7653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7654       };
7655     } catch (...) {
7656       {
7657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7658       };
7659     }
7660   }
7661
7662   jresult = (void *)result;
7663   return jresult;
7664 }
7665
7666
7667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7668   void * jresult ;
7669   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7670   Dali::Vector4 *arg2 = 0 ;
7671   Dali::Vector4 result;
7672
7673   arg1 = (Dali::Vector4 *)jarg1;
7674   arg2 = (Dali::Vector4 *)jarg2;
7675   if (!arg2) {
7676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7677     return 0;
7678   }
7679   {
7680     try {
7681       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7682     } catch (std::out_of_range& e) {
7683       {
7684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7685       };
7686     } catch (std::exception& e) {
7687       {
7688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7689       };
7690     } catch (Dali::DaliException e) {
7691       {
7692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7693       };
7694     } catch (...) {
7695       {
7696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7697       };
7698     }
7699   }
7700
7701   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7702   return jresult;
7703 }
7704
7705
7706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7707   void * jresult ;
7708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7709   Dali::Vector4 *arg2 = 0 ;
7710   Dali::Vector4 *result = 0 ;
7711
7712   arg1 = (Dali::Vector4 *)jarg1;
7713   arg2 = (Dali::Vector4 *)jarg2;
7714   if (!arg2) {
7715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7716     return 0;
7717   }
7718   {
7719     try {
7720       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7721     } catch (std::out_of_range& e) {
7722       {
7723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7724       };
7725     } catch (std::exception& e) {
7726       {
7727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7728       };
7729     } catch (Dali::DaliException e) {
7730       {
7731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7732       };
7733     } catch (...) {
7734       {
7735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7736       };
7737     }
7738   }
7739
7740   jresult = (void *)result;
7741   return jresult;
7742 }
7743
7744
7745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7746   void * jresult ;
7747   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7748   Dali::Vector4 *arg2 = 0 ;
7749   Dali::Vector4 result;
7750
7751   arg1 = (Dali::Vector4 *)jarg1;
7752   arg2 = (Dali::Vector4 *)jarg2;
7753   if (!arg2) {
7754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7755     return 0;
7756   }
7757   {
7758     try {
7759       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7760     } catch (std::out_of_range& e) {
7761       {
7762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7763       };
7764     } catch (std::exception& e) {
7765       {
7766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7767       };
7768     } catch (Dali::DaliException e) {
7769       {
7770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7771       };
7772     } catch (...) {
7773       {
7774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7775       };
7776     }
7777   }
7778
7779   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7780   return jresult;
7781 }
7782
7783
7784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7785   void * jresult ;
7786   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7787   float arg2 ;
7788   Dali::Vector4 result;
7789
7790   arg1 = (Dali::Vector4 *)jarg1;
7791   arg2 = (float)jarg2;
7792   {
7793     try {
7794       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7795     } catch (std::out_of_range& e) {
7796       {
7797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7798       };
7799     } catch (std::exception& e) {
7800       {
7801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7802       };
7803     } catch (Dali::DaliException e) {
7804       {
7805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7806       };
7807     } catch (...) {
7808       {
7809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7810       };
7811     }
7812   }
7813
7814   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7815   return jresult;
7816 }
7817
7818
7819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7820   void * jresult ;
7821   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7822   Dali::Vector4 *arg2 = 0 ;
7823   Dali::Vector4 *result = 0 ;
7824
7825   arg1 = (Dali::Vector4 *)jarg1;
7826   arg2 = (Dali::Vector4 *)jarg2;
7827   if (!arg2) {
7828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7829     return 0;
7830   }
7831   {
7832     try {
7833       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7834     } catch (std::out_of_range& e) {
7835       {
7836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7837       };
7838     } catch (std::exception& e) {
7839       {
7840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7841       };
7842     } catch (Dali::DaliException e) {
7843       {
7844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7845       };
7846     } catch (...) {
7847       {
7848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7849       };
7850     }
7851   }
7852
7853   jresult = (void *)result;
7854   return jresult;
7855 }
7856
7857
7858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7859   void * jresult ;
7860   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7861   float arg2 ;
7862   Dali::Vector4 *result = 0 ;
7863
7864   arg1 = (Dali::Vector4 *)jarg1;
7865   arg2 = (float)jarg2;
7866   {
7867     try {
7868       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7869     } catch (std::out_of_range& e) {
7870       {
7871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7872       };
7873     } catch (std::exception& e) {
7874       {
7875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7876       };
7877     } catch (Dali::DaliException e) {
7878       {
7879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7880       };
7881     } catch (...) {
7882       {
7883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7884       };
7885     }
7886   }
7887
7888   jresult = (void *)result;
7889   return jresult;
7890 }
7891
7892
7893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7894   void * jresult ;
7895   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7896   Dali::Vector4 *arg2 = 0 ;
7897   Dali::Vector4 result;
7898
7899   arg1 = (Dali::Vector4 *)jarg1;
7900   arg2 = (Dali::Vector4 *)jarg2;
7901   if (!arg2) {
7902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7903     return 0;
7904   }
7905   {
7906     try {
7907       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7908     } catch (std::out_of_range& e) {
7909       {
7910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7911       };
7912     } catch (std::exception& e) {
7913       {
7914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7915       };
7916     } catch (Dali::DaliException e) {
7917       {
7918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7919       };
7920     } catch (...) {
7921       {
7922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7923       };
7924     }
7925   }
7926
7927   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7928   return jresult;
7929 }
7930
7931
7932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7933   void * jresult ;
7934   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7935   float arg2 ;
7936   Dali::Vector4 result;
7937
7938   arg1 = (Dali::Vector4 *)jarg1;
7939   arg2 = (float)jarg2;
7940   {
7941     try {
7942       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7943     } catch (std::out_of_range& e) {
7944       {
7945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7946       };
7947     } catch (std::exception& e) {
7948       {
7949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7950       };
7951     } catch (Dali::DaliException e) {
7952       {
7953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7954       };
7955     } catch (...) {
7956       {
7957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7958       };
7959     }
7960   }
7961
7962   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7963   return jresult;
7964 }
7965
7966
7967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7968   void * jresult ;
7969   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7970   Dali::Vector4 *arg2 = 0 ;
7971   Dali::Vector4 *result = 0 ;
7972
7973   arg1 = (Dali::Vector4 *)jarg1;
7974   arg2 = (Dali::Vector4 *)jarg2;
7975   if (!arg2) {
7976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7977     return 0;
7978   }
7979   {
7980     try {
7981       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7982     } catch (std::out_of_range& e) {
7983       {
7984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7985       };
7986     } catch (std::exception& e) {
7987       {
7988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7989       };
7990     } catch (Dali::DaliException e) {
7991       {
7992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7993       };
7994     } catch (...) {
7995       {
7996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7997       };
7998     }
7999   }
8000
8001   jresult = (void *)result;
8002   return jresult;
8003 }
8004
8005
8006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8007   void * jresult ;
8008   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8009   float arg2 ;
8010   Dali::Vector4 *result = 0 ;
8011
8012   arg1 = (Dali::Vector4 *)jarg1;
8013   arg2 = (float)jarg2;
8014   {
8015     try {
8016       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8017     } catch (std::out_of_range& e) {
8018       {
8019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8020       };
8021     } catch (std::exception& e) {
8022       {
8023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8024       };
8025     } catch (Dali::DaliException e) {
8026       {
8027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8028       };
8029     } catch (...) {
8030       {
8031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8032       };
8033     }
8034   }
8035
8036   jresult = (void *)result;
8037   return jresult;
8038 }
8039
8040
8041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8042   void * jresult ;
8043   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8044   Dali::Vector4 result;
8045
8046   arg1 = (Dali::Vector4 *)jarg1;
8047   {
8048     try {
8049       result = ((Dali::Vector4 const *)arg1)->operator -();
8050     } catch (std::out_of_range& e) {
8051       {
8052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8053       };
8054     } catch (std::exception& e) {
8055       {
8056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8057       };
8058     } catch (Dali::DaliException e) {
8059       {
8060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8061       };
8062     } catch (...) {
8063       {
8064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8065       };
8066     }
8067   }
8068
8069   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8070   return jresult;
8071 }
8072
8073
8074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8075   unsigned int jresult ;
8076   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8077   Dali::Vector4 *arg2 = 0 ;
8078   bool result;
8079
8080   arg1 = (Dali::Vector4 *)jarg1;
8081   arg2 = (Dali::Vector4 *)jarg2;
8082   if (!arg2) {
8083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8084     return 0;
8085   }
8086   {
8087     try {
8088       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8089     } catch (std::out_of_range& e) {
8090       {
8091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8092       };
8093     } catch (std::exception& e) {
8094       {
8095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8096       };
8097     } catch (Dali::DaliException e) {
8098       {
8099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8100       };
8101     } catch (...) {
8102       {
8103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8104       };
8105     }
8106   }
8107
8108   jresult = result;
8109   return jresult;
8110 }
8111
8112
8113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8114   unsigned int jresult ;
8115   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8116   Dali::Vector4 *arg2 = 0 ;
8117   bool result;
8118
8119   arg1 = (Dali::Vector4 *)jarg1;
8120   arg2 = (Dali::Vector4 *)jarg2;
8121   if (!arg2) {
8122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8123     return 0;
8124   }
8125   {
8126     try {
8127       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8128     } catch (std::out_of_range& e) {
8129       {
8130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8131       };
8132     } catch (std::exception& e) {
8133       {
8134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8135       };
8136     } catch (Dali::DaliException e) {
8137       {
8138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8139       };
8140     } catch (...) {
8141       {
8142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8143       };
8144     }
8145   }
8146
8147   jresult = result;
8148   return jresult;
8149 }
8150
8151
8152 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8153   float jresult ;
8154   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8155   unsigned int arg2 ;
8156   float *result = 0 ;
8157
8158   arg1 = (Dali::Vector4 *)jarg1;
8159   arg2 = (unsigned int)jarg2;
8160   {
8161     try {
8162       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8163     } catch (std::out_of_range& e) {
8164       {
8165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8166       };
8167     } catch (std::exception& e) {
8168       {
8169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8170       };
8171     } catch (Dali::DaliException e) {
8172       {
8173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8174       };
8175     } catch (...) {
8176       {
8177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8178       };
8179     }
8180   }
8181
8182   jresult = *result;
8183   return jresult;
8184 }
8185
8186
8187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8188   float jresult ;
8189   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8190   Dali::Vector3 *arg2 = 0 ;
8191   float result;
8192
8193   arg1 = (Dali::Vector4 *)jarg1;
8194   arg2 = (Dali::Vector3 *)jarg2;
8195   if (!arg2) {
8196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8197     return 0;
8198   }
8199   {
8200     try {
8201       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8202     } catch (std::out_of_range& e) {
8203       {
8204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8205       };
8206     } catch (std::exception& e) {
8207       {
8208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8209       };
8210     } catch (Dali::DaliException e) {
8211       {
8212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8213       };
8214     } catch (...) {
8215       {
8216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8217       };
8218     }
8219   }
8220
8221   jresult = result;
8222   return jresult;
8223 }
8224
8225
8226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8227   float jresult ;
8228   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8229   Dali::Vector4 *arg2 = 0 ;
8230   float result;
8231
8232   arg1 = (Dali::Vector4 *)jarg1;
8233   arg2 = (Dali::Vector4 *)jarg2;
8234   if (!arg2) {
8235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8236     return 0;
8237   }
8238   {
8239     try {
8240       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8241     } catch (std::out_of_range& e) {
8242       {
8243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8244       };
8245     } catch (std::exception& e) {
8246       {
8247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8248       };
8249     } catch (Dali::DaliException e) {
8250       {
8251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8252       };
8253     } catch (...) {
8254       {
8255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8256       };
8257     }
8258   }
8259
8260   jresult = result;
8261   return jresult;
8262 }
8263
8264
8265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8266   float jresult ;
8267   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8268   Dali::Vector4 *arg2 = 0 ;
8269   float result;
8270
8271   arg1 = (Dali::Vector4 *)jarg1;
8272   arg2 = (Dali::Vector4 *)jarg2;
8273   if (!arg2) {
8274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8275     return 0;
8276   }
8277   {
8278     try {
8279       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8280     } catch (std::out_of_range& e) {
8281       {
8282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8283       };
8284     } catch (std::exception& e) {
8285       {
8286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8287       };
8288     } catch (Dali::DaliException e) {
8289       {
8290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8291       };
8292     } catch (...) {
8293       {
8294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8295       };
8296     }
8297   }
8298
8299   jresult = result;
8300   return jresult;
8301 }
8302
8303
8304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8305   void * jresult ;
8306   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8307   Dali::Vector4 *arg2 = 0 ;
8308   Dali::Vector4 result;
8309
8310   arg1 = (Dali::Vector4 *)jarg1;
8311   arg2 = (Dali::Vector4 *)jarg2;
8312   if (!arg2) {
8313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8314     return 0;
8315   }
8316   {
8317     try {
8318       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8319     } catch (std::out_of_range& e) {
8320       {
8321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8322       };
8323     } catch (std::exception& e) {
8324       {
8325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8326       };
8327     } catch (Dali::DaliException e) {
8328       {
8329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8330       };
8331     } catch (...) {
8332       {
8333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8334       };
8335     }
8336   }
8337
8338   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8339   return jresult;
8340 }
8341
8342
8343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8344   float jresult ;
8345   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8346   float result;
8347
8348   arg1 = (Dali::Vector4 *)jarg1;
8349   {
8350     try {
8351       result = (float)((Dali::Vector4 const *)arg1)->Length();
8352     } catch (std::out_of_range& e) {
8353       {
8354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8355       };
8356     } catch (std::exception& e) {
8357       {
8358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8359       };
8360     } catch (Dali::DaliException e) {
8361       {
8362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8363       };
8364     } catch (...) {
8365       {
8366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8367       };
8368     }
8369   }
8370
8371   jresult = result;
8372   return jresult;
8373 }
8374
8375
8376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8377   float jresult ;
8378   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8379   float result;
8380
8381   arg1 = (Dali::Vector4 *)jarg1;
8382   {
8383     try {
8384       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8385     } catch (std::out_of_range& e) {
8386       {
8387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8388       };
8389     } catch (std::exception& e) {
8390       {
8391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8392       };
8393     } catch (Dali::DaliException e) {
8394       {
8395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8396       };
8397     } catch (...) {
8398       {
8399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8400       };
8401     }
8402   }
8403
8404   jresult = result;
8405   return jresult;
8406 }
8407
8408
8409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8410   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8411
8412   arg1 = (Dali::Vector4 *)jarg1;
8413   {
8414     try {
8415       (arg1)->Normalize();
8416     } catch (std::out_of_range& e) {
8417       {
8418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8419       };
8420     } catch (std::exception& e) {
8421       {
8422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8423       };
8424     } catch (Dali::DaliException e) {
8425       {
8426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8427       };
8428     } catch (...) {
8429       {
8430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8431       };
8432     }
8433   }
8434
8435 }
8436
8437
8438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8439   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8440   Dali::Vector4 *arg2 = 0 ;
8441   Dali::Vector4 *arg3 = 0 ;
8442
8443   arg1 = (Dali::Vector4 *)jarg1;
8444   arg2 = (Dali::Vector4 *)jarg2;
8445   if (!arg2) {
8446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8447     return ;
8448   }
8449   arg3 = (Dali::Vector4 *)jarg3;
8450   if (!arg3) {
8451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8452     return ;
8453   }
8454   {
8455     try {
8456       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8457     } catch (std::out_of_range& e) {
8458       {
8459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8460       };
8461     } catch (std::exception& e) {
8462       {
8463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8464       };
8465     } catch (Dali::DaliException e) {
8466       {
8467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8468       };
8469     } catch (...) {
8470       {
8471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8472       };
8473     }
8474   }
8475
8476 }
8477
8478
8479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8480   void * jresult ;
8481   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8482   float *result = 0 ;
8483
8484   arg1 = (Dali::Vector4 *)jarg1;
8485   {
8486     try {
8487       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8488     } catch (std::out_of_range& e) {
8489       {
8490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8491       };
8492     } catch (std::exception& e) {
8493       {
8494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8495       };
8496     } catch (Dali::DaliException e) {
8497       {
8498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8499       };
8500     } catch (...) {
8501       {
8502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8503       };
8504     }
8505   }
8506
8507   jresult = (void *)result;
8508   return jresult;
8509 }
8510
8511
8512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8513   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8514   float arg2 ;
8515
8516   arg1 = (Dali::Vector4 *)jarg1;
8517   arg2 = (float)jarg2;
8518   if (arg1) (arg1)->x = arg2;
8519 }
8520
8521
8522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8523   float jresult ;
8524   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8525   float result;
8526
8527   arg1 = (Dali::Vector4 *)jarg1;
8528   result = (float) ((arg1)->x);
8529   jresult = result;
8530   return jresult;
8531 }
8532
8533
8534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8536   float arg2 ;
8537
8538   arg1 = (Dali::Vector4 *)jarg1;
8539   arg2 = (float)jarg2;
8540   if (arg1) (arg1)->r = arg2;
8541 }
8542
8543
8544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8545   float jresult ;
8546   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8547   float result;
8548
8549   arg1 = (Dali::Vector4 *)jarg1;
8550   result = (float) ((arg1)->r);
8551   jresult = result;
8552   return jresult;
8553 }
8554
8555
8556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8557   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8558   float arg2 ;
8559
8560   arg1 = (Dali::Vector4 *)jarg1;
8561   arg2 = (float)jarg2;
8562   if (arg1) (arg1)->s = arg2;
8563 }
8564
8565
8566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8567   float jresult ;
8568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8569   float result;
8570
8571   arg1 = (Dali::Vector4 *)jarg1;
8572   result = (float) ((arg1)->s);
8573   jresult = result;
8574   return jresult;
8575 }
8576
8577
8578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8580   float arg2 ;
8581
8582   arg1 = (Dali::Vector4 *)jarg1;
8583   arg2 = (float)jarg2;
8584   if (arg1) (arg1)->y = arg2;
8585 }
8586
8587
8588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8589   float jresult ;
8590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8591   float result;
8592
8593   arg1 = (Dali::Vector4 *)jarg1;
8594   result = (float) ((arg1)->y);
8595   jresult = result;
8596   return jresult;
8597 }
8598
8599
8600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8601   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8602   float arg2 ;
8603
8604   arg1 = (Dali::Vector4 *)jarg1;
8605   arg2 = (float)jarg2;
8606   if (arg1) (arg1)->g = arg2;
8607 }
8608
8609
8610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8611   float jresult ;
8612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8613   float result;
8614
8615   arg1 = (Dali::Vector4 *)jarg1;
8616   result = (float) ((arg1)->g);
8617   jresult = result;
8618   return jresult;
8619 }
8620
8621
8622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8623   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8624   float arg2 ;
8625
8626   arg1 = (Dali::Vector4 *)jarg1;
8627   arg2 = (float)jarg2;
8628   if (arg1) (arg1)->t = arg2;
8629 }
8630
8631
8632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8633   float jresult ;
8634   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8635   float result;
8636
8637   arg1 = (Dali::Vector4 *)jarg1;
8638   result = (float) ((arg1)->t);
8639   jresult = result;
8640   return jresult;
8641 }
8642
8643
8644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8645   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8646   float arg2 ;
8647
8648   arg1 = (Dali::Vector4 *)jarg1;
8649   arg2 = (float)jarg2;
8650   if (arg1) (arg1)->z = arg2;
8651 }
8652
8653
8654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8655   float jresult ;
8656   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8657   float result;
8658
8659   arg1 = (Dali::Vector4 *)jarg1;
8660   result = (float) ((arg1)->z);
8661   jresult = result;
8662   return jresult;
8663 }
8664
8665
8666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8668   float arg2 ;
8669
8670   arg1 = (Dali::Vector4 *)jarg1;
8671   arg2 = (float)jarg2;
8672   if (arg1) (arg1)->b = arg2;
8673 }
8674
8675
8676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8677   float jresult ;
8678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8679   float result;
8680
8681   arg1 = (Dali::Vector4 *)jarg1;
8682   result = (float) ((arg1)->b);
8683   jresult = result;
8684   return jresult;
8685 }
8686
8687
8688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8690   float arg2 ;
8691
8692   arg1 = (Dali::Vector4 *)jarg1;
8693   arg2 = (float)jarg2;
8694   if (arg1) (arg1)->p = arg2;
8695 }
8696
8697
8698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8699   float jresult ;
8700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8701   float result;
8702
8703   arg1 = (Dali::Vector4 *)jarg1;
8704   result = (float) ((arg1)->p);
8705   jresult = result;
8706   return jresult;
8707 }
8708
8709
8710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8712   float arg2 ;
8713
8714   arg1 = (Dali::Vector4 *)jarg1;
8715   arg2 = (float)jarg2;
8716   if (arg1) (arg1)->w = arg2;
8717 }
8718
8719
8720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8721   float jresult ;
8722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8723   float result;
8724
8725   arg1 = (Dali::Vector4 *)jarg1;
8726   result = (float) ((arg1)->w);
8727   jresult = result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8734   float arg2 ;
8735
8736   arg1 = (Dali::Vector4 *)jarg1;
8737   arg2 = (float)jarg2;
8738   if (arg1) (arg1)->a = arg2;
8739 }
8740
8741
8742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8743   float jresult ;
8744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8745   float result;
8746
8747   arg1 = (Dali::Vector4 *)jarg1;
8748   result = (float) ((arg1)->a);
8749   jresult = result;
8750   return jresult;
8751 }
8752
8753
8754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8756   float arg2 ;
8757
8758   arg1 = (Dali::Vector4 *)jarg1;
8759   arg2 = (float)jarg2;
8760   if (arg1) (arg1)->q = arg2;
8761 }
8762
8763
8764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8765   float jresult ;
8766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8767   float result;
8768
8769   arg1 = (Dali::Vector4 *)jarg1;
8770   result = (float) ((arg1)->q);
8771   jresult = result;
8772   return jresult;
8773 }
8774
8775
8776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8778
8779   arg1 = (Dali::Vector4 *)jarg1;
8780   {
8781     try {
8782       delete arg1;
8783     } catch (std::out_of_range& e) {
8784       {
8785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8786       };
8787     } catch (std::exception& e) {
8788       {
8789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8790       };
8791     } catch (Dali::DaliException e) {
8792       {
8793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8794       };
8795     } catch (...) {
8796       {
8797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8798       };
8799     }
8800   }
8801
8802 }
8803
8804
8805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8806   void * jresult ;
8807   Dali::Vector4 *arg1 = 0 ;
8808   Dali::Vector4 *arg2 = 0 ;
8809   Dali::Vector4 result;
8810
8811   arg1 = (Dali::Vector4 *)jarg1;
8812   if (!arg1) {
8813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8814     return 0;
8815   }
8816   arg2 = (Dali::Vector4 *)jarg2;
8817   if (!arg2) {
8818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8819     return 0;
8820   }
8821   {
8822     try {
8823       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8824     } catch (std::out_of_range& e) {
8825       {
8826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8827       };
8828     } catch (std::exception& e) {
8829       {
8830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8831       };
8832     } catch (Dali::DaliException e) {
8833       {
8834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8835       };
8836     } catch (...) {
8837       {
8838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8839       };
8840     }
8841   }
8842
8843   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8844   return jresult;
8845 }
8846
8847
8848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8849   void * jresult ;
8850   Dali::Vector4 *arg1 = 0 ;
8851   Dali::Vector4 *arg2 = 0 ;
8852   Dali::Vector4 result;
8853
8854   arg1 = (Dali::Vector4 *)jarg1;
8855   if (!arg1) {
8856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8857     return 0;
8858   }
8859   arg2 = (Dali::Vector4 *)jarg2;
8860   if (!arg2) {
8861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8862     return 0;
8863   }
8864   {
8865     try {
8866       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8867     } catch (std::out_of_range& e) {
8868       {
8869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8870       };
8871     } catch (std::exception& e) {
8872       {
8873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8874       };
8875     } catch (Dali::DaliException e) {
8876       {
8877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8878       };
8879     } catch (...) {
8880       {
8881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8882       };
8883     }
8884   }
8885
8886   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8887   return jresult;
8888 }
8889
8890
8891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8892   void * jresult ;
8893   Dali::Vector4 *arg1 = 0 ;
8894   float *arg2 = 0 ;
8895   float *arg3 = 0 ;
8896   float temp2 ;
8897   float temp3 ;
8898   Dali::Vector4 result;
8899
8900   arg1 = (Dali::Vector4 *)jarg1;
8901   if (!arg1) {
8902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8903     return 0;
8904   }
8905   temp2 = (float)jarg2;
8906   arg2 = &temp2;
8907   temp3 = (float)jarg3;
8908   arg3 = &temp3;
8909   {
8910     try {
8911       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8912     } catch (std::out_of_range& e) {
8913       {
8914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8915       };
8916     } catch (std::exception& e) {
8917       {
8918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8919       };
8920     } catch (Dali::DaliException e) {
8921       {
8922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8923       };
8924     } catch (...) {
8925       {
8926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8927       };
8928     }
8929   }
8930
8931   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8932   return jresult;
8933 }
8934
8935
8936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8937   void * jresult ;
8938   Dali::Uint16Pair *result = 0 ;
8939
8940   {
8941     try {
8942       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8943     } catch (std::out_of_range& e) {
8944       {
8945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8946       };
8947     } catch (std::exception& e) {
8948       {
8949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8950       };
8951     } catch (Dali::DaliException e) {
8952       {
8953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8954       };
8955     } catch (...) {
8956       {
8957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8958       };
8959     }
8960   }
8961
8962   jresult = (void *)result;
8963   return jresult;
8964 }
8965
8966
8967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8968   void * jresult ;
8969   uint32_t arg1 ;
8970   uint32_t arg2 ;
8971   Dali::Uint16Pair *result = 0 ;
8972
8973   arg1 = (uint32_t)jarg1;
8974   arg2 = (uint32_t)jarg2;
8975   {
8976     try {
8977       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8978     } catch (std::out_of_range& e) {
8979       {
8980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8981       };
8982     } catch (std::exception& e) {
8983       {
8984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8985       };
8986     } catch (Dali::DaliException e) {
8987       {
8988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8989       };
8990     } catch (...) {
8991       {
8992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8993       };
8994     }
8995   }
8996
8997   jresult = (void *)result;
8998   return jresult;
8999 }
9000
9001
9002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9003   void * jresult ;
9004   Dali::Uint16Pair *arg1 = 0 ;
9005   Dali::Uint16Pair *result = 0 ;
9006
9007   arg1 = (Dali::Uint16Pair *)jarg1;
9008   if (!arg1) {
9009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9010     return 0;
9011   }
9012   {
9013     try {
9014       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9015     } catch (std::out_of_range& e) {
9016       {
9017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9018       };
9019     } catch (std::exception& e) {
9020       {
9021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9022       };
9023     } catch (Dali::DaliException e) {
9024       {
9025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9026       };
9027     } catch (...) {
9028       {
9029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9030       };
9031     }
9032   }
9033
9034   jresult = (void *)result;
9035   return jresult;
9036 }
9037
9038
9039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9040   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9041   uint16_t arg2 ;
9042
9043   arg1 = (Dali::Uint16Pair *)jarg1;
9044   arg2 = (uint16_t)jarg2;
9045   {
9046     try {
9047       (arg1)->SetWidth(arg2);
9048     } catch (std::out_of_range& e) {
9049       {
9050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9051       };
9052     } catch (std::exception& e) {
9053       {
9054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9055       };
9056     } catch (Dali::DaliException e) {
9057       {
9058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9059       };
9060     } catch (...) {
9061       {
9062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9063       };
9064     }
9065   }
9066
9067 }
9068
9069
9070 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9071   unsigned short jresult ;
9072   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9073   uint16_t result;
9074
9075   arg1 = (Dali::Uint16Pair *)jarg1;
9076   {
9077     try {
9078       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9079     } catch (std::out_of_range& e) {
9080       {
9081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9082       };
9083     } catch (std::exception& e) {
9084       {
9085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9086       };
9087     } catch (Dali::DaliException e) {
9088       {
9089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9090       };
9091     } catch (...) {
9092       {
9093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9094       };
9095     }
9096   }
9097
9098   jresult = result;
9099   return jresult;
9100 }
9101
9102
9103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9104   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9105   uint16_t arg2 ;
9106
9107   arg1 = (Dali::Uint16Pair *)jarg1;
9108   arg2 = (uint16_t)jarg2;
9109   {
9110     try {
9111       (arg1)->SetHeight(arg2);
9112     } catch (std::out_of_range& e) {
9113       {
9114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9115       };
9116     } catch (std::exception& e) {
9117       {
9118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9119       };
9120     } catch (Dali::DaliException e) {
9121       {
9122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9123       };
9124     } catch (...) {
9125       {
9126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9127       };
9128     }
9129   }
9130
9131 }
9132
9133
9134 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9135   unsigned short jresult ;
9136   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9137   uint16_t result;
9138
9139   arg1 = (Dali::Uint16Pair *)jarg1;
9140   {
9141     try {
9142       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9143     } catch (std::out_of_range& e) {
9144       {
9145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9146       };
9147     } catch (std::exception& e) {
9148       {
9149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9150       };
9151     } catch (Dali::DaliException e) {
9152       {
9153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9154       };
9155     } catch (...) {
9156       {
9157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9158       };
9159     }
9160   }
9161
9162   jresult = result;
9163   return jresult;
9164 }
9165
9166
9167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9168   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9169   uint16_t arg2 ;
9170
9171   arg1 = (Dali::Uint16Pair *)jarg1;
9172   arg2 = (uint16_t)jarg2;
9173   {
9174     try {
9175       (arg1)->SetX(arg2);
9176     } catch (std::out_of_range& e) {
9177       {
9178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9179       };
9180     } catch (std::exception& e) {
9181       {
9182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9183       };
9184     } catch (Dali::DaliException e) {
9185       {
9186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9187       };
9188     } catch (...) {
9189       {
9190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9191       };
9192     }
9193   }
9194
9195 }
9196
9197
9198 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9199   unsigned short jresult ;
9200   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9201   uint16_t result;
9202
9203   arg1 = (Dali::Uint16Pair *)jarg1;
9204   {
9205     try {
9206       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9207     } catch (std::out_of_range& e) {
9208       {
9209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9210       };
9211     } catch (std::exception& e) {
9212       {
9213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9214       };
9215     } catch (Dali::DaliException e) {
9216       {
9217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9218       };
9219     } catch (...) {
9220       {
9221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9222       };
9223     }
9224   }
9225
9226   jresult = result;
9227   return jresult;
9228 }
9229
9230
9231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9232   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9233   uint16_t arg2 ;
9234
9235   arg1 = (Dali::Uint16Pair *)jarg1;
9236   arg2 = (uint16_t)jarg2;
9237   {
9238     try {
9239       (arg1)->SetY(arg2);
9240     } catch (std::out_of_range& e) {
9241       {
9242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9243       };
9244     } catch (std::exception& e) {
9245       {
9246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9247       };
9248     } catch (Dali::DaliException e) {
9249       {
9250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9251       };
9252     } catch (...) {
9253       {
9254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9255       };
9256     }
9257   }
9258
9259 }
9260
9261
9262 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9263   unsigned short jresult ;
9264   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9265   uint16_t result;
9266
9267   arg1 = (Dali::Uint16Pair *)jarg1;
9268   {
9269     try {
9270       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9271     } catch (std::out_of_range& e) {
9272       {
9273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9274       };
9275     } catch (std::exception& e) {
9276       {
9277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9278       };
9279     } catch (Dali::DaliException e) {
9280       {
9281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9282       };
9283     } catch (...) {
9284       {
9285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9286       };
9287     }
9288   }
9289
9290   jresult = result;
9291   return jresult;
9292 }
9293
9294
9295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9296   void * jresult ;
9297   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9298   Dali::Uint16Pair *arg2 = 0 ;
9299   Dali::Uint16Pair *result = 0 ;
9300
9301   arg1 = (Dali::Uint16Pair *)jarg1;
9302   arg2 = (Dali::Uint16Pair *)jarg2;
9303   if (!arg2) {
9304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9305     return 0;
9306   }
9307   {
9308     try {
9309       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9310     } catch (std::out_of_range& e) {
9311       {
9312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9313       };
9314     } catch (std::exception& e) {
9315       {
9316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9317       };
9318     } catch (Dali::DaliException e) {
9319       {
9320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9321       };
9322     } catch (...) {
9323       {
9324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9325       };
9326     }
9327   }
9328
9329   jresult = (void *)result;
9330   return jresult;
9331 }
9332
9333
9334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9335   unsigned int jresult ;
9336   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9337   Dali::Uint16Pair *arg2 = 0 ;
9338   bool result;
9339
9340   arg1 = (Dali::Uint16Pair *)jarg1;
9341   arg2 = (Dali::Uint16Pair *)jarg2;
9342   if (!arg2) {
9343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9344     return 0;
9345   }
9346   {
9347     try {
9348       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9349     } catch (std::out_of_range& e) {
9350       {
9351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9352       };
9353     } catch (std::exception& e) {
9354       {
9355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9356       };
9357     } catch (Dali::DaliException e) {
9358       {
9359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9360       };
9361     } catch (...) {
9362       {
9363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9364       };
9365     }
9366   }
9367
9368   jresult = result;
9369   return jresult;
9370 }
9371
9372
9373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9374   unsigned int jresult ;
9375   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9376   Dali::Uint16Pair *arg2 = 0 ;
9377   bool result;
9378
9379   arg1 = (Dali::Uint16Pair *)jarg1;
9380   arg2 = (Dali::Uint16Pair *)jarg2;
9381   if (!arg2) {
9382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9383     return 0;
9384   }
9385   {
9386     try {
9387       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9388     } catch (std::out_of_range& e) {
9389       {
9390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9391       };
9392     } catch (std::exception& e) {
9393       {
9394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9395       };
9396     } catch (Dali::DaliException e) {
9397       {
9398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9399       };
9400     } catch (...) {
9401       {
9402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9403       };
9404     }
9405   }
9406
9407   jresult = result;
9408   return jresult;
9409 }
9410
9411
9412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9413   unsigned int jresult ;
9414   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9415   Dali::Uint16Pair *arg2 = 0 ;
9416   bool result;
9417
9418   arg1 = (Dali::Uint16Pair *)jarg1;
9419   arg2 = (Dali::Uint16Pair *)jarg2;
9420   if (!arg2) {
9421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9422     return 0;
9423   }
9424   {
9425     try {
9426       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9427     } catch (std::out_of_range& e) {
9428       {
9429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9430       };
9431     } catch (std::exception& e) {
9432       {
9433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9434       };
9435     } catch (Dali::DaliException e) {
9436       {
9437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9438       };
9439     } catch (...) {
9440       {
9441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9442       };
9443     }
9444   }
9445
9446   jresult = result;
9447   return jresult;
9448 }
9449
9450
9451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9452   unsigned int jresult ;
9453   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9454   Dali::Uint16Pair *arg2 = 0 ;
9455   bool result;
9456
9457   arg1 = (Dali::Uint16Pair *)jarg1;
9458   arg2 = (Dali::Uint16Pair *)jarg2;
9459   if (!arg2) {
9460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9461     return 0;
9462   }
9463   {
9464     try {
9465       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9466     } catch (std::out_of_range& e) {
9467       {
9468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9469       };
9470     } catch (std::exception& e) {
9471       {
9472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9473       };
9474     } catch (Dali::DaliException e) {
9475       {
9476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9477       };
9478     } catch (...) {
9479       {
9480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9481       };
9482     }
9483   }
9484
9485   jresult = result;
9486   return jresult;
9487 }
9488
9489
9490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9491   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9492
9493   arg1 = (Dali::Uint16Pair *)jarg1;
9494   {
9495     try {
9496       delete arg1;
9497     } catch (std::out_of_range& e) {
9498       {
9499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9500       };
9501     } catch (std::exception& e) {
9502       {
9503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9504       };
9505     } catch (Dali::DaliException e) {
9506       {
9507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9508       };
9509     } catch (...) {
9510       {
9511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9512       };
9513     }
9514   }
9515
9516 }
9517
9518
9519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9520   void * jresult ;
9521   Dali::Degree *result = 0 ;
9522
9523   {
9524     try {
9525       result = (Dali::Degree *)new Dali::Degree();
9526     } catch (std::out_of_range& e) {
9527       {
9528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9529       };
9530     } catch (std::exception& e) {
9531       {
9532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9533       };
9534     } catch (Dali::DaliException e) {
9535       {
9536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9537       };
9538     } catch (...) {
9539       {
9540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9541       };
9542     }
9543   }
9544
9545   jresult = (void *)result;
9546   return jresult;
9547 }
9548
9549
9550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9551   void * jresult ;
9552   float arg1 ;
9553   Dali::Degree *result = 0 ;
9554
9555   arg1 = (float)jarg1;
9556   {
9557     try {
9558       result = (Dali::Degree *)new Dali::Degree(arg1);
9559     } catch (std::out_of_range& e) {
9560       {
9561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9562       };
9563     } catch (std::exception& e) {
9564       {
9565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9566       };
9567     } catch (Dali::DaliException e) {
9568       {
9569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9570       };
9571     } catch (...) {
9572       {
9573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9574       };
9575     }
9576   }
9577
9578   jresult = (void *)result;
9579   return jresult;
9580 }
9581
9582
9583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9584   void * jresult ;
9585   Dali::Radian arg1 ;
9586   Dali::Radian *argp1 ;
9587   Dali::Degree *result = 0 ;
9588
9589   argp1 = (Dali::Radian *)jarg1;
9590   if (!argp1) {
9591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9592     return 0;
9593   }
9594   arg1 = *argp1;
9595   {
9596     try {
9597       result = (Dali::Degree *)new Dali::Degree(arg1);
9598     } catch (std::out_of_range& e) {
9599       {
9600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9601       };
9602     } catch (std::exception& e) {
9603       {
9604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9605       };
9606     } catch (Dali::DaliException e) {
9607       {
9608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9609       };
9610     } catch (...) {
9611       {
9612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9613       };
9614     }
9615   }
9616
9617   jresult = (void *)result;
9618   return jresult;
9619 }
9620
9621
9622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9623   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9624   float arg2 ;
9625
9626   arg1 = (Dali::Degree *)jarg1;
9627   arg2 = (float)jarg2;
9628   if (arg1) (arg1)->degree = arg2;
9629 }
9630
9631
9632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9633   float jresult ;
9634   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9635   float result;
9636
9637   arg1 = (Dali::Degree *)jarg1;
9638   result = (float) ((arg1)->degree);
9639   jresult = result;
9640   return jresult;
9641 }
9642
9643
9644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9645   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9646
9647   arg1 = (Dali::Degree *)jarg1;
9648   {
9649     try {
9650       delete arg1;
9651     } catch (std::out_of_range& e) {
9652       {
9653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9654       };
9655     } catch (std::exception& e) {
9656       {
9657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9658       };
9659     } catch (Dali::DaliException e) {
9660       {
9661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9662       };
9663     } catch (...) {
9664       {
9665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9666       };
9667     }
9668   }
9669
9670 }
9671
9672
9673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9674   void * jresult ;
9675   Dali::Radian *result = 0 ;
9676
9677   result = (Dali::Radian *)&Dali::ANGLE_360;
9678   jresult = (void *)result;
9679   return jresult;
9680 }
9681
9682
9683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9684   void * jresult ;
9685   Dali::Radian *result = 0 ;
9686
9687   result = (Dali::Radian *)&Dali::ANGLE_315;
9688   jresult = (void *)result;
9689   return jresult;
9690 }
9691
9692
9693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9694   void * jresult ;
9695   Dali::Radian *result = 0 ;
9696
9697   result = (Dali::Radian *)&Dali::ANGLE_270;
9698   jresult = (void *)result;
9699   return jresult;
9700 }
9701
9702
9703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9704   void * jresult ;
9705   Dali::Radian *result = 0 ;
9706
9707   result = (Dali::Radian *)&Dali::ANGLE_225;
9708   jresult = (void *)result;
9709   return jresult;
9710 }
9711
9712
9713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9714   void * jresult ;
9715   Dali::Radian *result = 0 ;
9716
9717   result = (Dali::Radian *)&Dali::ANGLE_180;
9718   jresult = (void *)result;
9719   return jresult;
9720 }
9721
9722
9723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9724   void * jresult ;
9725   Dali::Radian *result = 0 ;
9726
9727   result = (Dali::Radian *)&Dali::ANGLE_135;
9728   jresult = (void *)result;
9729   return jresult;
9730 }
9731
9732
9733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9734   void * jresult ;
9735   Dali::Radian *result = 0 ;
9736
9737   result = (Dali::Radian *)&Dali::ANGLE_120;
9738   jresult = (void *)result;
9739   return jresult;
9740 }
9741
9742
9743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9744   void * jresult ;
9745   Dali::Radian *result = 0 ;
9746
9747   result = (Dali::Radian *)&Dali::ANGLE_90;
9748   jresult = (void *)result;
9749   return jresult;
9750 }
9751
9752
9753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9754   void * jresult ;
9755   Dali::Radian *result = 0 ;
9756
9757   result = (Dali::Radian *)&Dali::ANGLE_60;
9758   jresult = (void *)result;
9759   return jresult;
9760 }
9761
9762
9763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9764   void * jresult ;
9765   Dali::Radian *result = 0 ;
9766
9767   result = (Dali::Radian *)&Dali::ANGLE_45;
9768   jresult = (void *)result;
9769   return jresult;
9770 }
9771
9772
9773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9774   void * jresult ;
9775   Dali::Radian *result = 0 ;
9776
9777   result = (Dali::Radian *)&Dali::ANGLE_30;
9778   jresult = (void *)result;
9779   return jresult;
9780 }
9781
9782
9783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9784   void * jresult ;
9785   Dali::Radian *result = 0 ;
9786
9787   result = (Dali::Radian *)&Dali::ANGLE_0;
9788   jresult = (void *)result;
9789   return jresult;
9790 }
9791
9792
9793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9794   unsigned int jresult ;
9795   Dali::Degree *arg1 = 0 ;
9796   Dali::Degree *arg2 = 0 ;
9797   bool result;
9798
9799   arg1 = (Dali::Degree *)jarg1;
9800   if (!arg1) {
9801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9802     return 0;
9803   }
9804   arg2 = (Dali::Degree *)jarg2;
9805   if (!arg2) {
9806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9807     return 0;
9808   }
9809   {
9810     try {
9811       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9812     } catch (std::out_of_range& e) {
9813       {
9814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9815       };
9816     } catch (std::exception& e) {
9817       {
9818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9819       };
9820     } catch (Dali::DaliException e) {
9821       {
9822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9823       };
9824     } catch (...) {
9825       {
9826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9827       };
9828     }
9829   }
9830
9831   jresult = result;
9832   return jresult;
9833 }
9834
9835
9836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9837   unsigned int jresult ;
9838   Dali::Degree *arg1 = 0 ;
9839   Dali::Degree *arg2 = 0 ;
9840   bool result;
9841
9842   arg1 = (Dali::Degree *)jarg1;
9843   if (!arg1) {
9844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9845     return 0;
9846   }
9847   arg2 = (Dali::Degree *)jarg2;
9848   if (!arg2) {
9849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9850     return 0;
9851   }
9852   {
9853     try {
9854       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9855     } catch (std::out_of_range& e) {
9856       {
9857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9858       };
9859     } catch (std::exception& e) {
9860       {
9861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9862       };
9863     } catch (Dali::DaliException e) {
9864       {
9865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9866       };
9867     } catch (...) {
9868       {
9869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9870       };
9871     }
9872   }
9873
9874   jresult = result;
9875   return jresult;
9876 }
9877
9878
9879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9880   void * jresult ;
9881   Dali::Degree arg1 ;
9882   float arg2 ;
9883   float arg3 ;
9884   Dali::Degree *argp1 ;
9885   Dali::Degree result;
9886
9887   argp1 = (Dali::Degree *)jarg1;
9888   if (!argp1) {
9889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9890     return 0;
9891   }
9892   arg1 = *argp1;
9893   arg2 = (float)jarg2;
9894   arg3 = (float)jarg3;
9895   {
9896     try {
9897       result = Dali::Clamp(arg1,arg2,arg3);
9898     } catch (std::out_of_range& e) {
9899       {
9900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9901       };
9902     } catch (std::exception& e) {
9903       {
9904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9905       };
9906     } catch (Dali::DaliException e) {
9907       {
9908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9909       };
9910     } catch (...) {
9911       {
9912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9913       };
9914     }
9915   }
9916
9917   jresult = new Dali::Degree((const Dali::Degree &)result);
9918   return jresult;
9919 }
9920
9921
9922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9923   void * jresult ;
9924   Dali::Radian *result = 0 ;
9925
9926   {
9927     try {
9928       result = (Dali::Radian *)new Dali::Radian();
9929     } catch (std::out_of_range& e) {
9930       {
9931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9932       };
9933     } catch (std::exception& e) {
9934       {
9935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9936       };
9937     } catch (Dali::DaliException e) {
9938       {
9939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9940       };
9941     } catch (...) {
9942       {
9943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9944       };
9945     }
9946   }
9947
9948   jresult = (void *)result;
9949   return jresult;
9950 }
9951
9952
9953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9954   void * jresult ;
9955   float arg1 ;
9956   Dali::Radian *result = 0 ;
9957
9958   arg1 = (float)jarg1;
9959   {
9960     try {
9961       result = (Dali::Radian *)new Dali::Radian(arg1);
9962     } catch (std::out_of_range& e) {
9963       {
9964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9965       };
9966     } catch (std::exception& e) {
9967       {
9968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9969       };
9970     } catch (Dali::DaliException e) {
9971       {
9972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9973       };
9974     } catch (...) {
9975       {
9976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9977       };
9978     }
9979   }
9980
9981   jresult = (void *)result;
9982   return jresult;
9983 }
9984
9985
9986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9987   void * jresult ;
9988   Dali::Degree arg1 ;
9989   Dali::Degree *argp1 ;
9990   Dali::Radian *result = 0 ;
9991
9992   argp1 = (Dali::Degree *)jarg1;
9993   if (!argp1) {
9994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9995     return 0;
9996   }
9997   arg1 = *argp1;
9998   {
9999     try {
10000       result = (Dali::Radian *)new Dali::Radian(arg1);
10001     } catch (std::out_of_range& e) {
10002       {
10003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10004       };
10005     } catch (std::exception& e) {
10006       {
10007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10008       };
10009     } catch (Dali::DaliException e) {
10010       {
10011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10012       };
10013     } catch (...) {
10014       {
10015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10016       };
10017     }
10018   }
10019
10020   jresult = (void *)result;
10021   return jresult;
10022 }
10023
10024
10025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10026   void * jresult ;
10027   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10028   float arg2 ;
10029   Dali::Radian *result = 0 ;
10030
10031   arg1 = (Dali::Radian *)jarg1;
10032   arg2 = (float)jarg2;
10033   {
10034     try {
10035       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10036     } catch (std::out_of_range& e) {
10037       {
10038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10039       };
10040     } catch (std::exception& e) {
10041       {
10042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10043       };
10044     } catch (Dali::DaliException e) {
10045       {
10046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10047       };
10048     } catch (...) {
10049       {
10050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10051       };
10052     }
10053   }
10054
10055   jresult = (void *)result;
10056   return jresult;
10057 }
10058
10059
10060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10061   void * jresult ;
10062   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10063   Dali::Degree arg2 ;
10064   Dali::Degree *argp2 ;
10065   Dali::Radian *result = 0 ;
10066
10067   arg1 = (Dali::Radian *)jarg1;
10068   argp2 = (Dali::Degree *)jarg2;
10069   if (!argp2) {
10070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10071     return 0;
10072   }
10073   arg2 = *argp2;
10074   {
10075     try {
10076       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10077     } catch (std::out_of_range& e) {
10078       {
10079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10080       };
10081     } catch (std::exception& e) {
10082       {
10083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10084       };
10085     } catch (Dali::DaliException e) {
10086       {
10087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10088       };
10089     } catch (...) {
10090       {
10091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10092       };
10093     }
10094   }
10095
10096   jresult = (void *)result;
10097   return jresult;
10098 }
10099
10100
10101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10102   float jresult ;
10103   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10104   float result;
10105
10106   arg1 = (Dali::Radian *)jarg1;
10107   {
10108     try {
10109       result = (float)((Dali::Radian const *)arg1)->operator float();
10110     } catch (std::out_of_range& e) {
10111       {
10112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10113       };
10114     } catch (std::exception& e) {
10115       {
10116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10117       };
10118     } catch (Dali::DaliException e) {
10119       {
10120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10121       };
10122     } catch (...) {
10123       {
10124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10125       };
10126     }
10127   }
10128
10129   jresult = result;
10130   return jresult;
10131 }
10132
10133
10134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10135   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10136   float arg2 ;
10137
10138   arg1 = (Dali::Radian *)jarg1;
10139   arg2 = (float)jarg2;
10140   if (arg1) (arg1)->radian = arg2;
10141 }
10142
10143
10144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10145   float jresult ;
10146   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10147   float result;
10148
10149   arg1 = (Dali::Radian *)jarg1;
10150   result = (float) ((arg1)->radian);
10151   jresult = result;
10152   return jresult;
10153 }
10154
10155
10156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10157   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10158
10159   arg1 = (Dali::Radian *)jarg1;
10160   {
10161     try {
10162       delete arg1;
10163     } catch (std::out_of_range& e) {
10164       {
10165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10166       };
10167     } catch (std::exception& e) {
10168       {
10169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10170       };
10171     } catch (Dali::DaliException e) {
10172       {
10173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10174       };
10175     } catch (...) {
10176       {
10177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10178       };
10179     }
10180   }
10181
10182 }
10183
10184
10185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10186   unsigned int jresult ;
10187   Dali::Radian arg1 ;
10188   Dali::Radian arg2 ;
10189   Dali::Radian *argp1 ;
10190   Dali::Radian *argp2 ;
10191   bool result;
10192
10193   argp1 = (Dali::Radian *)jarg1;
10194   if (!argp1) {
10195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10196     return 0;
10197   }
10198   arg1 = *argp1;
10199   argp2 = (Dali::Radian *)jarg2;
10200   if (!argp2) {
10201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10202     return 0;
10203   }
10204   arg2 = *argp2;
10205   {
10206     try {
10207       result = (bool)Dali::operator ==(arg1,arg2);
10208     } catch (std::out_of_range& e) {
10209       {
10210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10211       };
10212     } catch (std::exception& e) {
10213       {
10214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10215       };
10216     } catch (Dali::DaliException e) {
10217       {
10218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10219       };
10220     } catch (...) {
10221       {
10222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10223       };
10224     }
10225   }
10226
10227   jresult = result;
10228   return jresult;
10229 }
10230
10231
10232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10233   unsigned int jresult ;
10234   Dali::Radian arg1 ;
10235   Dali::Radian arg2 ;
10236   Dali::Radian *argp1 ;
10237   Dali::Radian *argp2 ;
10238   bool result;
10239
10240   argp1 = (Dali::Radian *)jarg1;
10241   if (!argp1) {
10242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10243     return 0;
10244   }
10245   arg1 = *argp1;
10246   argp2 = (Dali::Radian *)jarg2;
10247   if (!argp2) {
10248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10249     return 0;
10250   }
10251   arg2 = *argp2;
10252   {
10253     try {
10254       result = (bool)Dali::operator !=(arg1,arg2);
10255     } catch (std::out_of_range& e) {
10256       {
10257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10258       };
10259     } catch (std::exception& e) {
10260       {
10261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10262       };
10263     } catch (Dali::DaliException e) {
10264       {
10265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10266       };
10267     } catch (...) {
10268       {
10269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10270       };
10271     }
10272   }
10273
10274   jresult = result;
10275   return jresult;
10276 }
10277
10278
10279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10280   unsigned int jresult ;
10281   Dali::Radian arg1 ;
10282   Dali::Degree arg2 ;
10283   Dali::Radian *argp1 ;
10284   Dali::Degree *argp2 ;
10285   bool result;
10286
10287   argp1 = (Dali::Radian *)jarg1;
10288   if (!argp1) {
10289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10290     return 0;
10291   }
10292   arg1 = *argp1;
10293   argp2 = (Dali::Degree *)jarg2;
10294   if (!argp2) {
10295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10296     return 0;
10297   }
10298   arg2 = *argp2;
10299   {
10300     try {
10301       result = (bool)Dali::operator ==(arg1,arg2);
10302     } catch (std::out_of_range& e) {
10303       {
10304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10305       };
10306     } catch (std::exception& e) {
10307       {
10308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10309       };
10310     } catch (Dali::DaliException e) {
10311       {
10312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10313       };
10314     } catch (...) {
10315       {
10316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10317       };
10318     }
10319   }
10320
10321   jresult = result;
10322   return jresult;
10323 }
10324
10325
10326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10327   unsigned int jresult ;
10328   Dali::Radian arg1 ;
10329   Dali::Degree arg2 ;
10330   Dali::Radian *argp1 ;
10331   Dali::Degree *argp2 ;
10332   bool result;
10333
10334   argp1 = (Dali::Radian *)jarg1;
10335   if (!argp1) {
10336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10337     return 0;
10338   }
10339   arg1 = *argp1;
10340   argp2 = (Dali::Degree *)jarg2;
10341   if (!argp2) {
10342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10343     return 0;
10344   }
10345   arg2 = *argp2;
10346   {
10347     try {
10348       result = (bool)Dali::operator !=(arg1,arg2);
10349     } catch (std::out_of_range& e) {
10350       {
10351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10352       };
10353     } catch (std::exception& e) {
10354       {
10355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10356       };
10357     } catch (Dali::DaliException e) {
10358       {
10359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10360       };
10361     } catch (...) {
10362       {
10363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10364       };
10365     }
10366   }
10367
10368   jresult = result;
10369   return jresult;
10370 }
10371
10372
10373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10374   unsigned int jresult ;
10375   Dali::Degree arg1 ;
10376   Dali::Radian arg2 ;
10377   Dali::Degree *argp1 ;
10378   Dali::Radian *argp2 ;
10379   bool result;
10380
10381   argp1 = (Dali::Degree *)jarg1;
10382   if (!argp1) {
10383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10384     return 0;
10385   }
10386   arg1 = *argp1;
10387   argp2 = (Dali::Radian *)jarg2;
10388   if (!argp2) {
10389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10390     return 0;
10391   }
10392   arg2 = *argp2;
10393   {
10394     try {
10395       result = (bool)Dali::operator ==(arg1,arg2);
10396     } catch (std::out_of_range& e) {
10397       {
10398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10399       };
10400     } catch (std::exception& e) {
10401       {
10402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10403       };
10404     } catch (Dali::DaliException e) {
10405       {
10406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10407       };
10408     } catch (...) {
10409       {
10410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10411       };
10412     }
10413   }
10414
10415   jresult = result;
10416   return jresult;
10417 }
10418
10419
10420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10421   unsigned int jresult ;
10422   Dali::Degree arg1 ;
10423   Dali::Radian arg2 ;
10424   Dali::Degree *argp1 ;
10425   Dali::Radian *argp2 ;
10426   bool result;
10427
10428   argp1 = (Dali::Degree *)jarg1;
10429   if (!argp1) {
10430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10431     return 0;
10432   }
10433   arg1 = *argp1;
10434   argp2 = (Dali::Radian *)jarg2;
10435   if (!argp2) {
10436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10437     return 0;
10438   }
10439   arg2 = *argp2;
10440   {
10441     try {
10442       result = (bool)Dali::operator !=(arg1,arg2);
10443     } catch (std::out_of_range& e) {
10444       {
10445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10446       };
10447     } catch (std::exception& e) {
10448       {
10449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10450       };
10451     } catch (Dali::DaliException e) {
10452       {
10453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10454       };
10455     } catch (...) {
10456       {
10457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10458       };
10459     }
10460   }
10461
10462   jresult = result;
10463   return jresult;
10464 }
10465
10466
10467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10468   unsigned int jresult ;
10469   Dali::Radian arg1 ;
10470   Dali::Radian arg2 ;
10471   Dali::Radian *argp1 ;
10472   Dali::Radian *argp2 ;
10473   bool result;
10474
10475   argp1 = (Dali::Radian *)jarg1;
10476   if (!argp1) {
10477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10478     return 0;
10479   }
10480   arg1 = *argp1;
10481   argp2 = (Dali::Radian *)jarg2;
10482   if (!argp2) {
10483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10484     return 0;
10485   }
10486   arg2 = *argp2;
10487   {
10488     try {
10489       result = (bool)Dali::operator >(arg1,arg2);
10490     } catch (std::out_of_range& e) {
10491       {
10492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10493       };
10494     } catch (std::exception& e) {
10495       {
10496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10497       };
10498     } catch (Dali::DaliException e) {
10499       {
10500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10501       };
10502     } catch (...) {
10503       {
10504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10505       };
10506     }
10507   }
10508
10509   jresult = result;
10510   return jresult;
10511 }
10512
10513
10514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10515   unsigned int jresult ;
10516   Dali::Radian arg1 ;
10517   Dali::Degree arg2 ;
10518   Dali::Radian *argp1 ;
10519   Dali::Degree *argp2 ;
10520   bool result;
10521
10522   argp1 = (Dali::Radian *)jarg1;
10523   if (!argp1) {
10524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10525     return 0;
10526   }
10527   arg1 = *argp1;
10528   argp2 = (Dali::Degree *)jarg2;
10529   if (!argp2) {
10530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10531     return 0;
10532   }
10533   arg2 = *argp2;
10534   {
10535     try {
10536       result = (bool)Dali::operator >(arg1,arg2);
10537     } catch (std::out_of_range& e) {
10538       {
10539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10540       };
10541     } catch (std::exception& e) {
10542       {
10543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10544       };
10545     } catch (Dali::DaliException e) {
10546       {
10547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10548       };
10549     } catch (...) {
10550       {
10551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10552       };
10553     }
10554   }
10555
10556   jresult = result;
10557   return jresult;
10558 }
10559
10560
10561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10562   unsigned int jresult ;
10563   Dali::Degree arg1 ;
10564   Dali::Radian arg2 ;
10565   Dali::Degree *argp1 ;
10566   Dali::Radian *argp2 ;
10567   bool result;
10568
10569   argp1 = (Dali::Degree *)jarg1;
10570   if (!argp1) {
10571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10572     return 0;
10573   }
10574   arg1 = *argp1;
10575   argp2 = (Dali::Radian *)jarg2;
10576   if (!argp2) {
10577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10578     return 0;
10579   }
10580   arg2 = *argp2;
10581   {
10582     try {
10583       result = (bool)Dali::operator >(arg1,arg2);
10584     } catch (std::out_of_range& e) {
10585       {
10586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10587       };
10588     } catch (std::exception& e) {
10589       {
10590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10591       };
10592     } catch (Dali::DaliException e) {
10593       {
10594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10595       };
10596     } catch (...) {
10597       {
10598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10599       };
10600     }
10601   }
10602
10603   jresult = result;
10604   return jresult;
10605 }
10606
10607
10608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10609   unsigned int jresult ;
10610   Dali::Radian arg1 ;
10611   Dali::Radian arg2 ;
10612   Dali::Radian *argp1 ;
10613   Dali::Radian *argp2 ;
10614   bool result;
10615
10616   argp1 = (Dali::Radian *)jarg1;
10617   if (!argp1) {
10618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10619     return 0;
10620   }
10621   arg1 = *argp1;
10622   argp2 = (Dali::Radian *)jarg2;
10623   if (!argp2) {
10624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10625     return 0;
10626   }
10627   arg2 = *argp2;
10628   {
10629     try {
10630       result = (bool)Dali::operator <(arg1,arg2);
10631     } catch (std::out_of_range& e) {
10632       {
10633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10634       };
10635     } catch (std::exception& e) {
10636       {
10637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10638       };
10639     } catch (Dali::DaliException e) {
10640       {
10641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10642       };
10643     } catch (...) {
10644       {
10645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10646       };
10647     }
10648   }
10649
10650   jresult = result;
10651   return jresult;
10652 }
10653
10654
10655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10656   unsigned int jresult ;
10657   Dali::Radian arg1 ;
10658   Dali::Degree arg2 ;
10659   Dali::Radian *argp1 ;
10660   Dali::Degree *argp2 ;
10661   bool result;
10662
10663   argp1 = (Dali::Radian *)jarg1;
10664   if (!argp1) {
10665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10666     return 0;
10667   }
10668   arg1 = *argp1;
10669   argp2 = (Dali::Degree *)jarg2;
10670   if (!argp2) {
10671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10672     return 0;
10673   }
10674   arg2 = *argp2;
10675   {
10676     try {
10677       result = (bool)Dali::operator <(arg1,arg2);
10678     } catch (std::out_of_range& e) {
10679       {
10680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10681       };
10682     } catch (std::exception& e) {
10683       {
10684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10685       };
10686     } catch (Dali::DaliException e) {
10687       {
10688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10689       };
10690     } catch (...) {
10691       {
10692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10693       };
10694     }
10695   }
10696
10697   jresult = result;
10698   return jresult;
10699 }
10700
10701
10702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10703   unsigned int jresult ;
10704   Dali::Degree arg1 ;
10705   Dali::Radian arg2 ;
10706   Dali::Degree *argp1 ;
10707   Dali::Radian *argp2 ;
10708   bool result;
10709
10710   argp1 = (Dali::Degree *)jarg1;
10711   if (!argp1) {
10712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10713     return 0;
10714   }
10715   arg1 = *argp1;
10716   argp2 = (Dali::Radian *)jarg2;
10717   if (!argp2) {
10718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10719     return 0;
10720   }
10721   arg2 = *argp2;
10722   {
10723     try {
10724       result = (bool)Dali::operator <(arg1,arg2);
10725     } catch (std::out_of_range& e) {
10726       {
10727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10728       };
10729     } catch (std::exception& e) {
10730       {
10731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10732       };
10733     } catch (Dali::DaliException e) {
10734       {
10735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10736       };
10737     } catch (...) {
10738       {
10739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10740       };
10741     }
10742   }
10743
10744   jresult = result;
10745   return jresult;
10746 }
10747
10748
10749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10750   void * jresult ;
10751   Dali::Radian arg1 ;
10752   float arg2 ;
10753   Dali::Radian *argp1 ;
10754   Dali::Radian result;
10755
10756   argp1 = (Dali::Radian *)jarg1;
10757   if (!argp1) {
10758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10759     return 0;
10760   }
10761   arg1 = *argp1;
10762   arg2 = (float)jarg2;
10763   {
10764     try {
10765       result = Dali::operator *(arg1,arg2);
10766     } catch (std::out_of_range& e) {
10767       {
10768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10769       };
10770     } catch (std::exception& e) {
10771       {
10772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10773       };
10774     } catch (Dali::DaliException e) {
10775       {
10776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10777       };
10778     } catch (...) {
10779       {
10780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10781       };
10782     }
10783   }
10784
10785   jresult = new Dali::Radian((const Dali::Radian &)result);
10786   return jresult;
10787 }
10788
10789
10790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10791   void * jresult ;
10792   Dali::Radian arg1 ;
10793   Dali::Radian *argp1 ;
10794   Dali::Radian result;
10795
10796   argp1 = (Dali::Radian *)jarg1;
10797   if (!argp1) {
10798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10799     return 0;
10800   }
10801   arg1 = *argp1;
10802   {
10803     try {
10804       result = Dali::operator -(arg1);
10805     } catch (std::out_of_range& e) {
10806       {
10807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10808       };
10809     } catch (std::exception& e) {
10810       {
10811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10812       };
10813     } catch (Dali::DaliException e) {
10814       {
10815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10816       };
10817     } catch (...) {
10818       {
10819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10820       };
10821     }
10822   }
10823
10824   jresult = new Dali::Radian((const Dali::Radian &)result);
10825   return jresult;
10826 }
10827
10828
10829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10830   void * jresult ;
10831   Dali::Radian arg1 ;
10832   float arg2 ;
10833   float arg3 ;
10834   Dali::Radian *argp1 ;
10835   Dali::Radian result;
10836
10837   argp1 = (Dali::Radian *)jarg1;
10838   if (!argp1) {
10839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10840     return 0;
10841   }
10842   arg1 = *argp1;
10843   arg2 = (float)jarg2;
10844   arg3 = (float)jarg3;
10845   {
10846     try {
10847       result = Dali::Clamp(arg1,arg2,arg3);
10848     } catch (std::out_of_range& e) {
10849       {
10850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10851       };
10852     } catch (std::exception& e) {
10853       {
10854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10855       };
10856     } catch (Dali::DaliException e) {
10857       {
10858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10859       };
10860     } catch (...) {
10861       {
10862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10863       };
10864     }
10865   }
10866
10867   jresult = new Dali::Radian((const Dali::Radian &)result);
10868   return jresult;
10869 }
10870
10871
10872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10873   void * jresult ;
10874   Dali::Quaternion *result = 0 ;
10875
10876   {
10877     try {
10878       result = (Dali::Quaternion *)new Dali::Quaternion();
10879     } catch (std::out_of_range& e) {
10880       {
10881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10882       };
10883     } catch (std::exception& e) {
10884       {
10885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10886       };
10887     } catch (Dali::DaliException e) {
10888       {
10889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10890       };
10891     } catch (...) {
10892       {
10893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10894       };
10895     }
10896   }
10897
10898   jresult = (void *)result;
10899   return jresult;
10900 }
10901
10902
10903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10904   void * jresult ;
10905   Dali::Radian arg1 ;
10906   Dali::Vector3 *arg2 = 0 ;
10907   Dali::Radian *argp1 ;
10908   Dali::Quaternion *result = 0 ;
10909
10910   argp1 = (Dali::Radian *)jarg1;
10911   if (!argp1) {
10912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10913     return 0;
10914   }
10915   arg1 = *argp1;
10916   arg2 = (Dali::Vector3 *)jarg2;
10917   if (!arg2) {
10918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10919     return 0;
10920   }
10921   {
10922     try {
10923       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10924     } catch (std::out_of_range& e) {
10925       {
10926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10927       };
10928     } catch (std::exception& e) {
10929       {
10930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10931       };
10932     } catch (Dali::DaliException e) {
10933       {
10934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10935       };
10936     } catch (...) {
10937       {
10938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10939       };
10940     }
10941   }
10942
10943   jresult = (void *)result;
10944   return jresult;
10945 }
10946
10947
10948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10949   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10950
10951   arg1 = (Dali::Quaternion *)jarg1;
10952   {
10953     try {
10954       delete arg1;
10955     } catch (std::out_of_range& e) {
10956       {
10957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10958       };
10959     } catch (std::exception& e) {
10960       {
10961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10962       };
10963     } catch (Dali::DaliException e) {
10964       {
10965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10966       };
10967     } catch (...) {
10968       {
10969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10970       };
10971     }
10972   }
10973
10974 }
10975
10976
10977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10978   void * jresult ;
10979   Dali::Quaternion *result = 0 ;
10980
10981   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10982   jresult = (void *)result;
10983   return jresult;
10984 }
10985
10986
10987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10988   unsigned int jresult ;
10989   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10990   bool result;
10991
10992   arg1 = (Dali::Quaternion *)jarg1;
10993   {
10994     try {
10995       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10996     } catch (std::out_of_range& e) {
10997       {
10998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10999       };
11000     } catch (std::exception& e) {
11001       {
11002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11003       };
11004     } catch (Dali::DaliException e) {
11005       {
11006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11007       };
11008     } catch (...) {
11009       {
11010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11011       };
11012     }
11013   }
11014
11015   jresult = result;
11016   return jresult;
11017 }
11018
11019
11020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11021   unsigned int jresult ;
11022   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11023   Dali::Vector3 *arg2 = 0 ;
11024   Dali::Radian *arg3 = 0 ;
11025   bool result;
11026
11027   arg1 = (Dali::Quaternion *)jarg1;
11028   arg2 = (Dali::Vector3 *)jarg2;
11029   if (!arg2) {
11030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11031     return 0;
11032   }
11033   arg3 = (Dali::Radian *)jarg3;
11034   if (!arg3) {
11035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11036     return 0;
11037   }
11038   {
11039     try {
11040       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11041     } catch (std::out_of_range& e) {
11042       {
11043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11044       };
11045     } catch (std::exception& e) {
11046       {
11047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11048       };
11049     } catch (Dali::DaliException e) {
11050       {
11051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11052       };
11053     } catch (...) {
11054       {
11055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11056       };
11057     }
11058   }
11059
11060   jresult = result;
11061   return jresult;
11062 }
11063
11064
11065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11066   void * jresult ;
11067   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11068   Dali::Quaternion *arg2 = 0 ;
11069   Dali::Quaternion result;
11070
11071   arg1 = (Dali::Quaternion *)jarg1;
11072   arg2 = (Dali::Quaternion *)jarg2;
11073   if (!arg2) {
11074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11075     return 0;
11076   }
11077   {
11078     try {
11079       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11080     } catch (std::out_of_range& e) {
11081       {
11082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11083       };
11084     } catch (std::exception& e) {
11085       {
11086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11087       };
11088     } catch (Dali::DaliException e) {
11089       {
11090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11091       };
11092     } catch (...) {
11093       {
11094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11095       };
11096     }
11097   }
11098
11099   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11100   return jresult;
11101 }
11102
11103
11104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11105   void * jresult ;
11106   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11107   Dali::Quaternion *arg2 = 0 ;
11108   Dali::Quaternion result;
11109
11110   arg1 = (Dali::Quaternion *)jarg1;
11111   arg2 = (Dali::Quaternion *)jarg2;
11112   if (!arg2) {
11113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11114     return 0;
11115   }
11116   {
11117     try {
11118       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11119     } catch (std::out_of_range& e) {
11120       {
11121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11122       };
11123     } catch (std::exception& e) {
11124       {
11125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11126       };
11127     } catch (Dali::DaliException e) {
11128       {
11129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11130       };
11131     } catch (...) {
11132       {
11133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11134       };
11135     }
11136   }
11137
11138   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11139   return jresult;
11140 }
11141
11142
11143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11144   void * jresult ;
11145   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11146   Dali::Quaternion *arg2 = 0 ;
11147   Dali::Quaternion result;
11148
11149   arg1 = (Dali::Quaternion *)jarg1;
11150   arg2 = (Dali::Quaternion *)jarg2;
11151   if (!arg2) {
11152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11153     return 0;
11154   }
11155   {
11156     try {
11157       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11158     } catch (std::out_of_range& e) {
11159       {
11160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11161       };
11162     } catch (std::exception& e) {
11163       {
11164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11165       };
11166     } catch (Dali::DaliException e) {
11167       {
11168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11169       };
11170     } catch (...) {
11171       {
11172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11173       };
11174     }
11175   }
11176
11177   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11178   return jresult;
11179 }
11180
11181
11182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11183   void * jresult ;
11184   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11185   Dali::Vector3 *arg2 = 0 ;
11186   Dali::Vector3 result;
11187
11188   arg1 = (Dali::Quaternion *)jarg1;
11189   arg2 = (Dali::Vector3 *)jarg2;
11190   if (!arg2) {
11191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11192     return 0;
11193   }
11194   {
11195     try {
11196       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11197     } catch (std::out_of_range& e) {
11198       {
11199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11200       };
11201     } catch (std::exception& e) {
11202       {
11203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11204       };
11205     } catch (Dali::DaliException e) {
11206       {
11207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11208       };
11209     } catch (...) {
11210       {
11211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11212       };
11213     }
11214   }
11215
11216   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11217   return jresult;
11218 }
11219
11220
11221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11222   void * jresult ;
11223   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11224   Dali::Quaternion *arg2 = 0 ;
11225   Dali::Quaternion result;
11226
11227   arg1 = (Dali::Quaternion *)jarg1;
11228   arg2 = (Dali::Quaternion *)jarg2;
11229   if (!arg2) {
11230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11231     return 0;
11232   }
11233   {
11234     try {
11235       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11236     } catch (std::out_of_range& e) {
11237       {
11238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11239       };
11240     } catch (std::exception& e) {
11241       {
11242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11243       };
11244     } catch (Dali::DaliException e) {
11245       {
11246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11247       };
11248     } catch (...) {
11249       {
11250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11251       };
11252     }
11253   }
11254
11255   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11256   return jresult;
11257 }
11258
11259
11260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11261   void * jresult ;
11262   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11263   float arg2 ;
11264   Dali::Quaternion result;
11265
11266   arg1 = (Dali::Quaternion *)jarg1;
11267   arg2 = (float)jarg2;
11268   {
11269     try {
11270       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11271     } catch (std::out_of_range& e) {
11272       {
11273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11274       };
11275     } catch (std::exception& e) {
11276       {
11277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11278       };
11279     } catch (Dali::DaliException e) {
11280       {
11281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11282       };
11283     } catch (...) {
11284       {
11285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11286       };
11287     }
11288   }
11289
11290   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11291   return jresult;
11292 }
11293
11294
11295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11296   void * jresult ;
11297   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11298   float arg2 ;
11299   Dali::Quaternion result;
11300
11301   arg1 = (Dali::Quaternion *)jarg1;
11302   arg2 = (float)jarg2;
11303   {
11304     try {
11305       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11306     } catch (std::out_of_range& e) {
11307       {
11308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11309       };
11310     } catch (std::exception& e) {
11311       {
11312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11313       };
11314     } catch (Dali::DaliException e) {
11315       {
11316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11317       };
11318     } catch (...) {
11319       {
11320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11321       };
11322     }
11323   }
11324
11325   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11326   return jresult;
11327 }
11328
11329
11330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11331   void * jresult ;
11332   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11333   Dali::Quaternion result;
11334
11335   arg1 = (Dali::Quaternion *)jarg1;
11336   {
11337     try {
11338       result = ((Dali::Quaternion const *)arg1)->operator -();
11339     } catch (std::out_of_range& e) {
11340       {
11341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11342       };
11343     } catch (std::exception& e) {
11344       {
11345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11346       };
11347     } catch (Dali::DaliException e) {
11348       {
11349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11350       };
11351     } catch (...) {
11352       {
11353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11354       };
11355     }
11356   }
11357
11358   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11359   return jresult;
11360 }
11361
11362
11363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11364   void * jresult ;
11365   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11366   Dali::Quaternion *arg2 = 0 ;
11367   Dali::Quaternion *result = 0 ;
11368
11369   arg1 = (Dali::Quaternion *)jarg1;
11370   arg2 = (Dali::Quaternion *)jarg2;
11371   if (!arg2) {
11372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11373     return 0;
11374   }
11375   {
11376     try {
11377       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11378     } catch (std::out_of_range& e) {
11379       {
11380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11381       };
11382     } catch (std::exception& e) {
11383       {
11384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11385       };
11386     } catch (Dali::DaliException e) {
11387       {
11388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11389       };
11390     } catch (...) {
11391       {
11392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11393       };
11394     }
11395   }
11396
11397   jresult = (void *)result;
11398   return jresult;
11399 }
11400
11401
11402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11403   void * jresult ;
11404   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11405   Dali::Quaternion *arg2 = 0 ;
11406   Dali::Quaternion *result = 0 ;
11407
11408   arg1 = (Dali::Quaternion *)jarg1;
11409   arg2 = (Dali::Quaternion *)jarg2;
11410   if (!arg2) {
11411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11412     return 0;
11413   }
11414   {
11415     try {
11416       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11417     } catch (std::out_of_range& e) {
11418       {
11419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11420       };
11421     } catch (std::exception& e) {
11422       {
11423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11424       };
11425     } catch (Dali::DaliException e) {
11426       {
11427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11428       };
11429     } catch (...) {
11430       {
11431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11432       };
11433     }
11434   }
11435
11436   jresult = (void *)result;
11437   return jresult;
11438 }
11439
11440
11441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11442   void * jresult ;
11443   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11444   Dali::Quaternion *arg2 = 0 ;
11445   Dali::Quaternion *result = 0 ;
11446
11447   arg1 = (Dali::Quaternion *)jarg1;
11448   arg2 = (Dali::Quaternion *)jarg2;
11449   if (!arg2) {
11450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11451     return 0;
11452   }
11453   {
11454     try {
11455       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11456     } catch (std::out_of_range& e) {
11457       {
11458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11459       };
11460     } catch (std::exception& e) {
11461       {
11462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11463       };
11464     } catch (Dali::DaliException e) {
11465       {
11466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11467       };
11468     } catch (...) {
11469       {
11470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11471       };
11472     }
11473   }
11474
11475   jresult = (void *)result;
11476   return jresult;
11477 }
11478
11479
11480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11481   void * jresult ;
11482   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11483   float arg2 ;
11484   Dali::Quaternion *result = 0 ;
11485
11486   arg1 = (Dali::Quaternion *)jarg1;
11487   arg2 = (float)jarg2;
11488   {
11489     try {
11490       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11491     } catch (std::out_of_range& e) {
11492       {
11493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11494       };
11495     } catch (std::exception& e) {
11496       {
11497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11498       };
11499     } catch (Dali::DaliException e) {
11500       {
11501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11502       };
11503     } catch (...) {
11504       {
11505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11506       };
11507     }
11508   }
11509
11510   jresult = (void *)result;
11511   return jresult;
11512 }
11513
11514
11515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11516   void * jresult ;
11517   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11518   float arg2 ;
11519   Dali::Quaternion *result = 0 ;
11520
11521   arg1 = (Dali::Quaternion *)jarg1;
11522   arg2 = (float)jarg2;
11523   {
11524     try {
11525       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11526     } catch (std::out_of_range& e) {
11527       {
11528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11529       };
11530     } catch (std::exception& e) {
11531       {
11532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11533       };
11534     } catch (Dali::DaliException e) {
11535       {
11536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11537       };
11538     } catch (...) {
11539       {
11540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11541       };
11542     }
11543   }
11544
11545   jresult = (void *)result;
11546   return jresult;
11547 }
11548
11549
11550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11551   unsigned int jresult ;
11552   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11553   Dali::Quaternion *arg2 = 0 ;
11554   bool result;
11555
11556   arg1 = (Dali::Quaternion *)jarg1;
11557   arg2 = (Dali::Quaternion *)jarg2;
11558   if (!arg2) {
11559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11560     return 0;
11561   }
11562   {
11563     try {
11564       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11565     } catch (std::out_of_range& e) {
11566       {
11567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11568       };
11569     } catch (std::exception& e) {
11570       {
11571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11572       };
11573     } catch (Dali::DaliException e) {
11574       {
11575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11576       };
11577     } catch (...) {
11578       {
11579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11580       };
11581     }
11582   }
11583
11584   jresult = result;
11585   return jresult;
11586 }
11587
11588
11589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11590   unsigned int jresult ;
11591   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11592   Dali::Quaternion *arg2 = 0 ;
11593   bool result;
11594
11595   arg1 = (Dali::Quaternion *)jarg1;
11596   arg2 = (Dali::Quaternion *)jarg2;
11597   if (!arg2) {
11598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11599     return 0;
11600   }
11601   {
11602     try {
11603       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11604     } catch (std::out_of_range& e) {
11605       {
11606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11607       };
11608     } catch (std::exception& e) {
11609       {
11610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11611       };
11612     } catch (Dali::DaliException e) {
11613       {
11614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11615       };
11616     } catch (...) {
11617       {
11618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11619       };
11620     }
11621   }
11622
11623   jresult = result;
11624   return jresult;
11625 }
11626
11627
11628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11629   float jresult ;
11630   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11631   float result;
11632
11633   arg1 = (Dali::Quaternion *)jarg1;
11634   {
11635     try {
11636       result = (float)((Dali::Quaternion const *)arg1)->Length();
11637     } catch (std::out_of_range& e) {
11638       {
11639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11640       };
11641     } catch (std::exception& e) {
11642       {
11643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11644       };
11645     } catch (Dali::DaliException e) {
11646       {
11647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11648       };
11649     } catch (...) {
11650       {
11651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11652       };
11653     }
11654   }
11655
11656   jresult = result;
11657   return jresult;
11658 }
11659
11660
11661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11662   float jresult ;
11663   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11664   float result;
11665
11666   arg1 = (Dali::Quaternion *)jarg1;
11667   {
11668     try {
11669       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11670     } catch (std::out_of_range& e) {
11671       {
11672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11673       };
11674     } catch (std::exception& e) {
11675       {
11676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11677       };
11678     } catch (Dali::DaliException e) {
11679       {
11680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11681       };
11682     } catch (...) {
11683       {
11684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11685       };
11686     }
11687   }
11688
11689   jresult = result;
11690   return jresult;
11691 }
11692
11693
11694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11695   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11696
11697   arg1 = (Dali::Quaternion *)jarg1;
11698   {
11699     try {
11700       (arg1)->Normalize();
11701     } catch (std::out_of_range& e) {
11702       {
11703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11704       };
11705     } catch (std::exception& e) {
11706       {
11707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11708       };
11709     } catch (Dali::DaliException e) {
11710       {
11711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11712       };
11713     } catch (...) {
11714       {
11715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11716       };
11717     }
11718   }
11719
11720 }
11721
11722
11723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11724   void * jresult ;
11725   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11726   Dali::Quaternion result;
11727
11728   arg1 = (Dali::Quaternion *)jarg1;
11729   {
11730     try {
11731       result = ((Dali::Quaternion const *)arg1)->Normalized();
11732     } catch (std::out_of_range& e) {
11733       {
11734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11735       };
11736     } catch (std::exception& e) {
11737       {
11738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11739       };
11740     } catch (Dali::DaliException e) {
11741       {
11742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11743       };
11744     } catch (...) {
11745       {
11746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11747       };
11748     }
11749   }
11750
11751   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11752   return jresult;
11753 }
11754
11755
11756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11757   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11758
11759   arg1 = (Dali::Quaternion *)jarg1;
11760   {
11761     try {
11762       (arg1)->Conjugate();
11763     } catch (std::out_of_range& e) {
11764       {
11765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11766       };
11767     } catch (std::exception& e) {
11768       {
11769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11770       };
11771     } catch (Dali::DaliException e) {
11772       {
11773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11774       };
11775     } catch (...) {
11776       {
11777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11778       };
11779     }
11780   }
11781
11782 }
11783
11784
11785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11786   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11787
11788   arg1 = (Dali::Quaternion *)jarg1;
11789   {
11790     try {
11791       (arg1)->Invert();
11792     } catch (std::out_of_range& e) {
11793       {
11794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11795       };
11796     } catch (std::exception& e) {
11797       {
11798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11799       };
11800     } catch (Dali::DaliException e) {
11801       {
11802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11803       };
11804     } catch (...) {
11805       {
11806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11807       };
11808     }
11809   }
11810
11811 }
11812
11813
11814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11815   void * jresult ;
11816   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11817   Dali::Quaternion result;
11818
11819   arg1 = (Dali::Quaternion *)jarg1;
11820   {
11821     try {
11822       result = ((Dali::Quaternion const *)arg1)->Log();
11823     } catch (std::out_of_range& e) {
11824       {
11825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11826       };
11827     } catch (std::exception& e) {
11828       {
11829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11830       };
11831     } catch (Dali::DaliException e) {
11832       {
11833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11834       };
11835     } catch (...) {
11836       {
11837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11838       };
11839     }
11840   }
11841
11842   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11843   return jresult;
11844 }
11845
11846
11847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11848   void * jresult ;
11849   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11850   Dali::Quaternion result;
11851
11852   arg1 = (Dali::Quaternion *)jarg1;
11853   {
11854     try {
11855       result = ((Dali::Quaternion const *)arg1)->Exp();
11856     } catch (std::out_of_range& e) {
11857       {
11858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11859       };
11860     } catch (std::exception& e) {
11861       {
11862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11863       };
11864     } catch (Dali::DaliException e) {
11865       {
11866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11867       };
11868     } catch (...) {
11869       {
11870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11871       };
11872     }
11873   }
11874
11875   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11876   return jresult;
11877 }
11878
11879
11880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11881   float jresult ;
11882   Dali::Quaternion *arg1 = 0 ;
11883   Dali::Quaternion *arg2 = 0 ;
11884   float result;
11885
11886   arg1 = (Dali::Quaternion *)jarg1;
11887   if (!arg1) {
11888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11889     return 0;
11890   }
11891   arg2 = (Dali::Quaternion *)jarg2;
11892   if (!arg2) {
11893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11894     return 0;
11895   }
11896   {
11897     try {
11898       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11899     } catch (std::out_of_range& e) {
11900       {
11901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11902       };
11903     } catch (std::exception& e) {
11904       {
11905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11906       };
11907     } catch (Dali::DaliException e) {
11908       {
11909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11910       };
11911     } catch (...) {
11912       {
11913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11914       };
11915     }
11916   }
11917
11918   jresult = result;
11919   return jresult;
11920 }
11921
11922
11923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11924   void * jresult ;
11925   Dali::Quaternion *arg1 = 0 ;
11926   Dali::Quaternion *arg2 = 0 ;
11927   float arg3 ;
11928   Dali::Quaternion result;
11929
11930   arg1 = (Dali::Quaternion *)jarg1;
11931   if (!arg1) {
11932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11933     return 0;
11934   }
11935   arg2 = (Dali::Quaternion *)jarg2;
11936   if (!arg2) {
11937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11938     return 0;
11939   }
11940   arg3 = (float)jarg3;
11941   {
11942     try {
11943       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11944     } catch (std::out_of_range& e) {
11945       {
11946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11947       };
11948     } catch (std::exception& e) {
11949       {
11950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11951       };
11952     } catch (Dali::DaliException e) {
11953       {
11954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11955       };
11956     } catch (...) {
11957       {
11958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11959       };
11960     }
11961   }
11962
11963   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11964   return jresult;
11965 }
11966
11967
11968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11969   void * jresult ;
11970   Dali::Quaternion *arg1 = 0 ;
11971   Dali::Quaternion *arg2 = 0 ;
11972   float arg3 ;
11973   Dali::Quaternion result;
11974
11975   arg1 = (Dali::Quaternion *)jarg1;
11976   if (!arg1) {
11977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11978     return 0;
11979   }
11980   arg2 = (Dali::Quaternion *)jarg2;
11981   if (!arg2) {
11982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11983     return 0;
11984   }
11985   arg3 = (float)jarg3;
11986   {
11987     try {
11988       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11989     } catch (std::out_of_range& e) {
11990       {
11991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11992       };
11993     } catch (std::exception& e) {
11994       {
11995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11996       };
11997     } catch (Dali::DaliException e) {
11998       {
11999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12000       };
12001     } catch (...) {
12002       {
12003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12004       };
12005     }
12006   }
12007
12008   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12009   return jresult;
12010 }
12011
12012
12013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12014   void * jresult ;
12015   Dali::Quaternion *arg1 = 0 ;
12016   Dali::Quaternion *arg2 = 0 ;
12017   float arg3 ;
12018   Dali::Quaternion result;
12019
12020   arg1 = (Dali::Quaternion *)jarg1;
12021   if (!arg1) {
12022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12023     return 0;
12024   }
12025   arg2 = (Dali::Quaternion *)jarg2;
12026   if (!arg2) {
12027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12028     return 0;
12029   }
12030   arg3 = (float)jarg3;
12031   {
12032     try {
12033       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12034     } catch (std::out_of_range& e) {
12035       {
12036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12037       };
12038     } catch (std::exception& e) {
12039       {
12040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12041       };
12042     } catch (Dali::DaliException e) {
12043       {
12044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12045       };
12046     } catch (...) {
12047       {
12048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12049       };
12050     }
12051   }
12052
12053   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12054   return jresult;
12055 }
12056
12057
12058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12059   void * jresult ;
12060   Dali::Quaternion *arg1 = 0 ;
12061   Dali::Quaternion *arg2 = 0 ;
12062   Dali::Quaternion *arg3 = 0 ;
12063   Dali::Quaternion *arg4 = 0 ;
12064   float arg5 ;
12065   Dali::Quaternion result;
12066
12067   arg1 = (Dali::Quaternion *)jarg1;
12068   if (!arg1) {
12069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12070     return 0;
12071   }
12072   arg2 = (Dali::Quaternion *)jarg2;
12073   if (!arg2) {
12074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12075     return 0;
12076   }
12077   arg3 = (Dali::Quaternion *)jarg3;
12078   if (!arg3) {
12079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12080     return 0;
12081   }
12082   arg4 = (Dali::Quaternion *)jarg4;
12083   if (!arg4) {
12084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12085     return 0;
12086   }
12087   arg5 = (float)jarg5;
12088   {
12089     try {
12090       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12091     } catch (std::out_of_range& e) {
12092       {
12093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12094       };
12095     } catch (std::exception& e) {
12096       {
12097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12098       };
12099     } catch (Dali::DaliException e) {
12100       {
12101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12102       };
12103     } catch (...) {
12104       {
12105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12106       };
12107     }
12108   }
12109
12110   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12111   return jresult;
12112 }
12113
12114
12115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12116   float jresult ;
12117   Dali::Quaternion *arg1 = 0 ;
12118   Dali::Quaternion *arg2 = 0 ;
12119   float result;
12120
12121   arg1 = (Dali::Quaternion *)jarg1;
12122   if (!arg1) {
12123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12124     return 0;
12125   }
12126   arg2 = (Dali::Quaternion *)jarg2;
12127   if (!arg2) {
12128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12129     return 0;
12130   }
12131   {
12132     try {
12133       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12134     } catch (std::out_of_range& e) {
12135       {
12136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12137       };
12138     } catch (std::exception& e) {
12139       {
12140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12141       };
12142     } catch (Dali::DaliException e) {
12143       {
12144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12145       };
12146     } catch (...) {
12147       {
12148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12149       };
12150     }
12151   }
12152
12153   jresult = result;
12154   return jresult;
12155 }
12156
12157
12158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12159   void * jresult ;
12160   Dali::Matrix *result = 0 ;
12161
12162   {
12163     try {
12164       result = (Dali::Matrix *)new Dali::Matrix();
12165     } catch (std::out_of_range& e) {
12166       {
12167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12168       };
12169     } catch (std::exception& e) {
12170       {
12171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12172       };
12173     } catch (Dali::DaliException e) {
12174       {
12175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12176       };
12177     } catch (...) {
12178       {
12179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12180       };
12181     }
12182   }
12183
12184   jresult = (void *)result;
12185   return jresult;
12186 }
12187
12188
12189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12190   void * jresult ;
12191   bool arg1 ;
12192   Dali::Matrix *result = 0 ;
12193
12194   arg1 = jarg1 ? true : false;
12195   {
12196     try {
12197       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12198     } catch (std::out_of_range& e) {
12199       {
12200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12201       };
12202     } catch (std::exception& e) {
12203       {
12204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12205       };
12206     } catch (Dali::DaliException e) {
12207       {
12208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12209       };
12210     } catch (...) {
12211       {
12212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12213       };
12214     }
12215   }
12216
12217   jresult = (void *)result;
12218   return jresult;
12219 }
12220
12221
12222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12223   void * jresult ;
12224   float *arg1 = (float *) 0 ;
12225   Dali::Matrix *result = 0 ;
12226
12227   arg1 = jarg1;
12228   {
12229     try {
12230       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12231     } catch (std::out_of_range& e) {
12232       {
12233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12234       };
12235     } catch (std::exception& e) {
12236       {
12237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12238       };
12239     } catch (Dali::DaliException e) {
12240       {
12241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12242       };
12243     } catch (...) {
12244       {
12245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12246       };
12247     }
12248   }
12249
12250   jresult = (void *)result;
12251
12252
12253   return jresult;
12254 }
12255
12256
12257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12258   void * jresult ;
12259   Dali::Quaternion *arg1 = 0 ;
12260   Dali::Matrix *result = 0 ;
12261
12262   arg1 = (Dali::Quaternion *)jarg1;
12263   if (!arg1) {
12264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12265     return 0;
12266   }
12267   {
12268     try {
12269       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12270     } catch (std::out_of_range& e) {
12271       {
12272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12273       };
12274     } catch (std::exception& e) {
12275       {
12276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12277       };
12278     } catch (Dali::DaliException e) {
12279       {
12280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12281       };
12282     } catch (...) {
12283       {
12284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12285       };
12286     }
12287   }
12288
12289   jresult = (void *)result;
12290   return jresult;
12291 }
12292
12293
12294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12295   void * jresult ;
12296   Dali::Matrix *arg1 = 0 ;
12297   Dali::Matrix *result = 0 ;
12298
12299   arg1 = (Dali::Matrix *)jarg1;
12300   if (!arg1) {
12301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12302     return 0;
12303   }
12304   {
12305     try {
12306       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12307     } catch (std::out_of_range& e) {
12308       {
12309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12310       };
12311     } catch (std::exception& e) {
12312       {
12313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12314       };
12315     } catch (Dali::DaliException e) {
12316       {
12317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12318       };
12319     } catch (...) {
12320       {
12321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12322       };
12323     }
12324   }
12325
12326   jresult = (void *)result;
12327   return jresult;
12328 }
12329
12330
12331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12332   void * jresult ;
12333   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12334   Dali::Matrix *arg2 = 0 ;
12335   Dali::Matrix *result = 0 ;
12336
12337   arg1 = (Dali::Matrix *)jarg1;
12338   arg2 = (Dali::Matrix *)jarg2;
12339   if (!arg2) {
12340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12341     return 0;
12342   }
12343   {
12344     try {
12345       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12346     } catch (std::out_of_range& e) {
12347       {
12348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12349       };
12350     } catch (std::exception& e) {
12351       {
12352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12353       };
12354     } catch (Dali::DaliException e) {
12355       {
12356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12357       };
12358     } catch (...) {
12359       {
12360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12361       };
12362     }
12363   }
12364
12365   jresult = (void *)result;
12366   return jresult;
12367 }
12368
12369
12370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12371   void * jresult ;
12372   Dali::Matrix *result = 0 ;
12373
12374   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12375   jresult = (void *)result;
12376   return jresult;
12377 }
12378
12379
12380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12381   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12382
12383   arg1 = (Dali::Matrix *)jarg1;
12384   {
12385     try {
12386       (arg1)->SetIdentity();
12387     } catch (std::out_of_range& e) {
12388       {
12389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12390       };
12391     } catch (std::exception& e) {
12392       {
12393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12394       };
12395     } catch (Dali::DaliException e) {
12396       {
12397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12398       };
12399     } catch (...) {
12400       {
12401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12402       };
12403     }
12404   }
12405
12406 }
12407
12408
12409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12410   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12411   Dali::Vector3 *arg2 = 0 ;
12412
12413   arg1 = (Dali::Matrix *)jarg1;
12414   arg2 = (Dali::Vector3 *)jarg2;
12415   if (!arg2) {
12416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12417     return ;
12418   }
12419   {
12420     try {
12421       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12422     } catch (std::out_of_range& e) {
12423       {
12424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12425       };
12426     } catch (std::exception& e) {
12427       {
12428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12429       };
12430     } catch (Dali::DaliException e) {
12431       {
12432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12433       };
12434     } catch (...) {
12435       {
12436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12437       };
12438     }
12439   }
12440
12441 }
12442
12443
12444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12445   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12446   Dali::Matrix *arg2 = 0 ;
12447
12448   arg1 = (Dali::Matrix *)jarg1;
12449   arg2 = (Dali::Matrix *)jarg2;
12450   if (!arg2) {
12451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12452     return ;
12453   }
12454   {
12455     try {
12456       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12457     } catch (std::out_of_range& e) {
12458       {
12459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12460       };
12461     } catch (std::exception& e) {
12462       {
12463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12464       };
12465     } catch (Dali::DaliException e) {
12466       {
12467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12468       };
12469     } catch (...) {
12470       {
12471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12472       };
12473     }
12474   }
12475
12476 }
12477
12478
12479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12480   unsigned int jresult ;
12481   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12482   bool result;
12483
12484   arg1 = (Dali::Matrix *)jarg1;
12485   {
12486     try {
12487       result = (bool)(arg1)->Invert();
12488     } catch (std::out_of_range& e) {
12489       {
12490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12491       };
12492     } catch (std::exception& e) {
12493       {
12494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12495       };
12496     } catch (Dali::DaliException e) {
12497       {
12498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12499       };
12500     } catch (...) {
12501       {
12502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12503       };
12504     }
12505   }
12506
12507   jresult = result;
12508   return jresult;
12509 }
12510
12511
12512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12513   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12514
12515   arg1 = (Dali::Matrix *)jarg1;
12516   {
12517     try {
12518       (arg1)->Transpose();
12519     } catch (std::out_of_range& e) {
12520       {
12521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12522       };
12523     } catch (std::exception& e) {
12524       {
12525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12526       };
12527     } catch (Dali::DaliException e) {
12528       {
12529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12530       };
12531     } catch (...) {
12532       {
12533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12534       };
12535     }
12536   }
12537
12538 }
12539
12540
12541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12542   void * jresult ;
12543   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12544   Dali::Vector3 result;
12545
12546   arg1 = (Dali::Matrix *)jarg1;
12547   {
12548     try {
12549       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12550     } catch (std::out_of_range& e) {
12551       {
12552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12553       };
12554     } catch (std::exception& e) {
12555       {
12556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12557       };
12558     } catch (Dali::DaliException e) {
12559       {
12560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12561       };
12562     } catch (...) {
12563       {
12564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12565       };
12566     }
12567   }
12568
12569   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12570   return jresult;
12571 }
12572
12573
12574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12575   void * jresult ;
12576   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12577   Dali::Vector3 result;
12578
12579   arg1 = (Dali::Matrix *)jarg1;
12580   {
12581     try {
12582       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12583     } catch (std::out_of_range& e) {
12584       {
12585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12586       };
12587     } catch (std::exception& e) {
12588       {
12589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12590       };
12591     } catch (Dali::DaliException e) {
12592       {
12593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12594       };
12595     } catch (...) {
12596       {
12597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12598       };
12599     }
12600   }
12601
12602   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12603   return jresult;
12604 }
12605
12606
12607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12608   void * jresult ;
12609   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12610   Dali::Vector3 result;
12611
12612   arg1 = (Dali::Matrix *)jarg1;
12613   {
12614     try {
12615       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12616     } catch (std::out_of_range& e) {
12617       {
12618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12619       };
12620     } catch (std::exception& e) {
12621       {
12622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12623       };
12624     } catch (Dali::DaliException e) {
12625       {
12626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12627       };
12628     } catch (...) {
12629       {
12630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12631       };
12632     }
12633   }
12634
12635   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12636   return jresult;
12637 }
12638
12639
12640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12641   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12642   Dali::Vector3 *arg2 = 0 ;
12643
12644   arg1 = (Dali::Matrix *)jarg1;
12645   arg2 = (Dali::Vector3 *)jarg2;
12646   if (!arg2) {
12647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12648     return ;
12649   }
12650   {
12651     try {
12652       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12653     } catch (std::out_of_range& e) {
12654       {
12655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12656       };
12657     } catch (std::exception& e) {
12658       {
12659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12660       };
12661     } catch (Dali::DaliException e) {
12662       {
12663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12664       };
12665     } catch (...) {
12666       {
12667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12668       };
12669     }
12670   }
12671
12672 }
12673
12674
12675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12676   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12677   Dali::Vector3 *arg2 = 0 ;
12678
12679   arg1 = (Dali::Matrix *)jarg1;
12680   arg2 = (Dali::Vector3 *)jarg2;
12681   if (!arg2) {
12682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12683     return ;
12684   }
12685   {
12686     try {
12687       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12688     } catch (std::out_of_range& e) {
12689       {
12690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12691       };
12692     } catch (std::exception& e) {
12693       {
12694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12695       };
12696     } catch (Dali::DaliException e) {
12697       {
12698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12699       };
12700     } catch (...) {
12701       {
12702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12703       };
12704     }
12705   }
12706
12707 }
12708
12709
12710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12711   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12712   Dali::Vector3 *arg2 = 0 ;
12713
12714   arg1 = (Dali::Matrix *)jarg1;
12715   arg2 = (Dali::Vector3 *)jarg2;
12716   if (!arg2) {
12717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12718     return ;
12719   }
12720   {
12721     try {
12722       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12723     } catch (std::out_of_range& e) {
12724       {
12725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12726       };
12727     } catch (std::exception& e) {
12728       {
12729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12730       };
12731     } catch (Dali::DaliException e) {
12732       {
12733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12734       };
12735     } catch (...) {
12736       {
12737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12738       };
12739     }
12740   }
12741
12742 }
12743
12744
12745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12746   void * jresult ;
12747   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12748   Dali::Vector4 *result = 0 ;
12749
12750   arg1 = (Dali::Matrix *)jarg1;
12751   {
12752     try {
12753       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12754     } catch (std::out_of_range& e) {
12755       {
12756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12757       };
12758     } catch (std::exception& e) {
12759       {
12760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12761       };
12762     } catch (Dali::DaliException e) {
12763       {
12764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12765       };
12766     } catch (...) {
12767       {
12768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12769       };
12770     }
12771   }
12772
12773   jresult = (void *)result;
12774   return jresult;
12775 }
12776
12777
12778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12779   void * jresult ;
12780   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12781   Dali::Vector3 *result = 0 ;
12782
12783   arg1 = (Dali::Matrix *)jarg1;
12784   {
12785     try {
12786       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12787     } catch (std::out_of_range& e) {
12788       {
12789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12790       };
12791     } catch (std::exception& e) {
12792       {
12793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12794       };
12795     } catch (Dali::DaliException e) {
12796       {
12797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12798       };
12799     } catch (...) {
12800       {
12801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12802       };
12803     }
12804   }
12805
12806   jresult = (void *)result;
12807   return jresult;
12808 }
12809
12810
12811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12812   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12813   Dali::Vector4 *arg2 = 0 ;
12814
12815   arg1 = (Dali::Matrix *)jarg1;
12816   arg2 = (Dali::Vector4 *)jarg2;
12817   if (!arg2) {
12818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12819     return ;
12820   }
12821   {
12822     try {
12823       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12824     } catch (std::out_of_range& e) {
12825       {
12826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12827       };
12828     } catch (std::exception& e) {
12829       {
12830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12831       };
12832     } catch (Dali::DaliException e) {
12833       {
12834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12835       };
12836     } catch (...) {
12837       {
12838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12839       };
12840     }
12841   }
12842
12843 }
12844
12845
12846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12847   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12848   Dali::Vector3 *arg2 = 0 ;
12849
12850   arg1 = (Dali::Matrix *)jarg1;
12851   arg2 = (Dali::Vector3 *)jarg2;
12852   if (!arg2) {
12853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12854     return ;
12855   }
12856   {
12857     try {
12858       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12859     } catch (std::out_of_range& e) {
12860       {
12861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12862       };
12863     } catch (std::exception& e) {
12864       {
12865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12866       };
12867     } catch (Dali::DaliException e) {
12868       {
12869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12870       };
12871     } catch (...) {
12872       {
12873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12874       };
12875     }
12876   }
12877
12878 }
12879
12880
12881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12882   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12883
12884   arg1 = (Dali::Matrix *)jarg1;
12885   {
12886     try {
12887       (arg1)->OrthoNormalize();
12888     } catch (std::out_of_range& e) {
12889       {
12890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12891       };
12892     } catch (std::exception& e) {
12893       {
12894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12895       };
12896     } catch (Dali::DaliException e) {
12897       {
12898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12899       };
12900     } catch (...) {
12901       {
12902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12903       };
12904     }
12905   }
12906
12907 }
12908
12909
12910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12911   void * jresult ;
12912   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12913   float *result = 0 ;
12914
12915   arg1 = (Dali::Matrix *)jarg1;
12916   {
12917     try {
12918       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12919     } catch (std::out_of_range& e) {
12920       {
12921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12922       };
12923     } catch (std::exception& e) {
12924       {
12925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12926       };
12927     } catch (Dali::DaliException e) {
12928       {
12929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12930       };
12931     } catch (...) {
12932       {
12933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12934       };
12935     }
12936   }
12937
12938   jresult = (void *)result;
12939   return jresult;
12940 }
12941
12942
12943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12944   Dali::Matrix *arg1 = 0 ;
12945   Dali::Matrix *arg2 = 0 ;
12946   Dali::Matrix *arg3 = 0 ;
12947
12948   arg1 = (Dali::Matrix *)jarg1;
12949   if (!arg1) {
12950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12951     return ;
12952   }
12953   arg2 = (Dali::Matrix *)jarg2;
12954   if (!arg2) {
12955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12956     return ;
12957   }
12958   arg3 = (Dali::Matrix *)jarg3;
12959   if (!arg3) {
12960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12961     return ;
12962   }
12963   {
12964     try {
12965       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12966     } catch (std::out_of_range& e) {
12967       {
12968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12969       };
12970     } catch (std::exception& e) {
12971       {
12972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12973       };
12974     } catch (Dali::DaliException e) {
12975       {
12976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12977       };
12978     } catch (...) {
12979       {
12980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12981       };
12982     }
12983   }
12984
12985 }
12986
12987
12988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12989   Dali::Matrix *arg1 = 0 ;
12990   Dali::Matrix *arg2 = 0 ;
12991   Dali::Quaternion *arg3 = 0 ;
12992
12993   arg1 = (Dali::Matrix *)jarg1;
12994   if (!arg1) {
12995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12996     return ;
12997   }
12998   arg2 = (Dali::Matrix *)jarg2;
12999   if (!arg2) {
13000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13001     return ;
13002   }
13003   arg3 = (Dali::Quaternion *)jarg3;
13004   if (!arg3) {
13005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13006     return ;
13007   }
13008   {
13009     try {
13010       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13011     } catch (std::out_of_range& e) {
13012       {
13013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13014       };
13015     } catch (std::exception& e) {
13016       {
13017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13018       };
13019     } catch (Dali::DaliException e) {
13020       {
13021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13022       };
13023     } catch (...) {
13024       {
13025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13026       };
13027     }
13028   }
13029
13030 }
13031
13032
13033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13034   void * jresult ;
13035   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13036   Dali::Vector4 *arg2 = 0 ;
13037   Dali::Vector4 result;
13038
13039   arg1 = (Dali::Matrix *)jarg1;
13040   arg2 = (Dali::Vector4 *)jarg2;
13041   if (!arg2) {
13042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13043     return 0;
13044   }
13045   {
13046     try {
13047       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13048     } catch (std::out_of_range& e) {
13049       {
13050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13051       };
13052     } catch (std::exception& e) {
13053       {
13054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13055       };
13056     } catch (Dali::DaliException e) {
13057       {
13058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13059       };
13060     } catch (...) {
13061       {
13062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13063       };
13064     }
13065   }
13066
13067   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13068   return jresult;
13069 }
13070
13071
13072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13073   unsigned int jresult ;
13074   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13075   Dali::Matrix *arg2 = 0 ;
13076   bool result;
13077
13078   arg1 = (Dali::Matrix *)jarg1;
13079   arg2 = (Dali::Matrix *)jarg2;
13080   if (!arg2) {
13081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13082     return 0;
13083   }
13084   {
13085     try {
13086       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13087     } catch (std::out_of_range& e) {
13088       {
13089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13090       };
13091     } catch (std::exception& e) {
13092       {
13093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13094       };
13095     } catch (Dali::DaliException e) {
13096       {
13097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13098       };
13099     } catch (...) {
13100       {
13101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13102       };
13103     }
13104   }
13105
13106   jresult = result;
13107   return jresult;
13108 }
13109
13110
13111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13112   unsigned int jresult ;
13113   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13114   Dali::Matrix *arg2 = 0 ;
13115   bool result;
13116
13117   arg1 = (Dali::Matrix *)jarg1;
13118   arg2 = (Dali::Matrix *)jarg2;
13119   if (!arg2) {
13120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13121     return 0;
13122   }
13123   {
13124     try {
13125       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13126     } catch (std::out_of_range& e) {
13127       {
13128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13129       };
13130     } catch (std::exception& e) {
13131       {
13132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13133       };
13134     } catch (Dali::DaliException e) {
13135       {
13136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13137       };
13138     } catch (...) {
13139       {
13140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13141       };
13142     }
13143   }
13144
13145   jresult = result;
13146   return jresult;
13147 }
13148
13149
13150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13151   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13152   Dali::Vector3 *arg2 = 0 ;
13153   Dali::Quaternion *arg3 = 0 ;
13154   Dali::Vector3 *arg4 = 0 ;
13155
13156   arg1 = (Dali::Matrix *)jarg1;
13157   arg2 = (Dali::Vector3 *)jarg2;
13158   if (!arg2) {
13159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13160     return ;
13161   }
13162   arg3 = (Dali::Quaternion *)jarg3;
13163   if (!arg3) {
13164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13165     return ;
13166   }
13167   arg4 = (Dali::Vector3 *)jarg4;
13168   if (!arg4) {
13169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13170     return ;
13171   }
13172   {
13173     try {
13174       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13175     } catch (std::out_of_range& e) {
13176       {
13177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13178       };
13179     } catch (std::exception& e) {
13180       {
13181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13182       };
13183     } catch (Dali::DaliException e) {
13184       {
13185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13186       };
13187     } catch (...) {
13188       {
13189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13190       };
13191     }
13192   }
13193
13194 }
13195
13196
13197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13198   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13199   Dali::Vector3 *arg2 = 0 ;
13200   Dali::Quaternion *arg3 = 0 ;
13201   Dali::Vector3 *arg4 = 0 ;
13202
13203   arg1 = (Dali::Matrix *)jarg1;
13204   arg2 = (Dali::Vector3 *)jarg2;
13205   if (!arg2) {
13206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13207     return ;
13208   }
13209   arg3 = (Dali::Quaternion *)jarg3;
13210   if (!arg3) {
13211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13212     return ;
13213   }
13214   arg4 = (Dali::Vector3 *)jarg4;
13215   if (!arg4) {
13216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13217     return ;
13218   }
13219   {
13220     try {
13221       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13222     } catch (std::out_of_range& e) {
13223       {
13224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13225       };
13226     } catch (std::exception& e) {
13227       {
13228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13229       };
13230     } catch (Dali::DaliException e) {
13231       {
13232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13233       };
13234     } catch (...) {
13235       {
13236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13237       };
13238     }
13239   }
13240
13241 }
13242
13243
13244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13245   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13246   Dali::Vector3 *arg2 = 0 ;
13247   Dali::Vector3 *arg3 = 0 ;
13248   Dali::Vector3 *arg4 = 0 ;
13249   Dali::Vector3 *arg5 = 0 ;
13250
13251   arg1 = (Dali::Matrix *)jarg1;
13252   arg2 = (Dali::Vector3 *)jarg2;
13253   if (!arg2) {
13254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13255     return ;
13256   }
13257   arg3 = (Dali::Vector3 *)jarg3;
13258   if (!arg3) {
13259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13260     return ;
13261   }
13262   arg4 = (Dali::Vector3 *)jarg4;
13263   if (!arg4) {
13264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13265     return ;
13266   }
13267   arg5 = (Dali::Vector3 *)jarg5;
13268   if (!arg5) {
13269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13270     return ;
13271   }
13272   {
13273     try {
13274       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13275     } catch (std::out_of_range& e) {
13276       {
13277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13278       };
13279     } catch (std::exception& e) {
13280       {
13281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13282       };
13283     } catch (Dali::DaliException e) {
13284       {
13285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13286       };
13287     } catch (...) {
13288       {
13289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13290       };
13291     }
13292   }
13293
13294 }
13295
13296
13297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13298   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13299   Dali::Vector3 *arg2 = 0 ;
13300   Dali::Quaternion *arg3 = 0 ;
13301   Dali::Vector3 *arg4 = 0 ;
13302
13303   arg1 = (Dali::Matrix *)jarg1;
13304   arg2 = (Dali::Vector3 *)jarg2;
13305   if (!arg2) {
13306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13307     return ;
13308   }
13309   arg3 = (Dali::Quaternion *)jarg3;
13310   if (!arg3) {
13311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13312     return ;
13313   }
13314   arg4 = (Dali::Vector3 *)jarg4;
13315   if (!arg4) {
13316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13317     return ;
13318   }
13319   {
13320     try {
13321       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13322     } catch (std::out_of_range& e) {
13323       {
13324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13325       };
13326     } catch (std::exception& e) {
13327       {
13328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13329       };
13330     } catch (Dali::DaliException e) {
13331       {
13332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13333       };
13334     } catch (...) {
13335       {
13336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13337       };
13338     }
13339   }
13340
13341 }
13342
13343
13344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13345   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13346
13347   arg1 = (Dali::Matrix *)jarg1;
13348   {
13349     try {
13350       delete arg1;
13351     } catch (std::out_of_range& e) {
13352       {
13353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13354       };
13355     } catch (std::exception& e) {
13356       {
13357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13358       };
13359     } catch (Dali::DaliException e) {
13360       {
13361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13362       };
13363     } catch (...) {
13364       {
13365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13366       };
13367     }
13368   }
13369
13370 }
13371
13372
13373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13374   void * jresult ;
13375   Dali::Matrix3 *result = 0 ;
13376
13377   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13378   jresult = (void *)result;
13379   return jresult;
13380 }
13381
13382
13383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13384   void * jresult ;
13385   Dali::Matrix3 *result = 0 ;
13386
13387   {
13388     try {
13389       result = (Dali::Matrix3 *)new Dali::Matrix3();
13390     } catch (std::out_of_range& e) {
13391       {
13392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13393       };
13394     } catch (std::exception& e) {
13395       {
13396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13397       };
13398     } catch (Dali::DaliException e) {
13399       {
13400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13401       };
13402     } catch (...) {
13403       {
13404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13405       };
13406     }
13407   }
13408
13409   jresult = (void *)result;
13410   return jresult;
13411 }
13412
13413
13414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13415   void * jresult ;
13416   Dali::Matrix3 *arg1 = 0 ;
13417   Dali::Matrix3 *result = 0 ;
13418
13419   arg1 = (Dali::Matrix3 *)jarg1;
13420   if (!arg1) {
13421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13422     return 0;
13423   }
13424   {
13425     try {
13426       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13427     } catch (std::out_of_range& e) {
13428       {
13429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13430       };
13431     } catch (std::exception& e) {
13432       {
13433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13434       };
13435     } catch (Dali::DaliException e) {
13436       {
13437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13438       };
13439     } catch (...) {
13440       {
13441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13442       };
13443     }
13444   }
13445
13446   jresult = (void *)result;
13447   return jresult;
13448 }
13449
13450
13451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13452   void * jresult ;
13453   Dali::Matrix *arg1 = 0 ;
13454   Dali::Matrix3 *result = 0 ;
13455
13456   arg1 = (Dali::Matrix *)jarg1;
13457   if (!arg1) {
13458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13459     return 0;
13460   }
13461   {
13462     try {
13463       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13464     } catch (std::out_of_range& e) {
13465       {
13466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13467       };
13468     } catch (std::exception& e) {
13469       {
13470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13471       };
13472     } catch (Dali::DaliException e) {
13473       {
13474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13475       };
13476     } catch (...) {
13477       {
13478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13479       };
13480     }
13481   }
13482
13483   jresult = (void *)result;
13484   return jresult;
13485 }
13486
13487
13488 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) {
13489   void * jresult ;
13490   float arg1 ;
13491   float arg2 ;
13492   float arg3 ;
13493   float arg4 ;
13494   float arg5 ;
13495   float arg6 ;
13496   float arg7 ;
13497   float arg8 ;
13498   float arg9 ;
13499   Dali::Matrix3 *result = 0 ;
13500
13501   arg1 = (float)jarg1;
13502   arg2 = (float)jarg2;
13503   arg3 = (float)jarg3;
13504   arg4 = (float)jarg4;
13505   arg5 = (float)jarg5;
13506   arg6 = (float)jarg6;
13507   arg7 = (float)jarg7;
13508   arg8 = (float)jarg8;
13509   arg9 = (float)jarg9;
13510   {
13511     try {
13512       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13513     } catch (std::out_of_range& e) {
13514       {
13515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13516       };
13517     } catch (std::exception& e) {
13518       {
13519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13520       };
13521     } catch (Dali::DaliException e) {
13522       {
13523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13524       };
13525     } catch (...) {
13526       {
13527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13528       };
13529     }
13530   }
13531
13532   jresult = (void *)result;
13533   return jresult;
13534 }
13535
13536
13537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13538   void * jresult ;
13539   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13540   Dali::Matrix3 *arg2 = 0 ;
13541   Dali::Matrix3 *result = 0 ;
13542
13543   arg1 = (Dali::Matrix3 *)jarg1;
13544   arg2 = (Dali::Matrix3 *)jarg2;
13545   if (!arg2) {
13546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13547     return 0;
13548   }
13549   {
13550     try {
13551       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13552     } catch (std::out_of_range& e) {
13553       {
13554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13555       };
13556     } catch (std::exception& e) {
13557       {
13558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13559       };
13560     } catch (Dali::DaliException e) {
13561       {
13562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13563       };
13564     } catch (...) {
13565       {
13566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13567       };
13568     }
13569   }
13570
13571   jresult = (void *)result;
13572   return jresult;
13573 }
13574
13575
13576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13577   void * jresult ;
13578   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13579   Dali::Matrix *arg2 = 0 ;
13580   Dali::Matrix3 *result = 0 ;
13581
13582   arg1 = (Dali::Matrix3 *)jarg1;
13583   arg2 = (Dali::Matrix *)jarg2;
13584   if (!arg2) {
13585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13586     return 0;
13587   }
13588   {
13589     try {
13590       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13591     } catch (std::out_of_range& e) {
13592       {
13593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13594       };
13595     } catch (std::exception& e) {
13596       {
13597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13598       };
13599     } catch (Dali::DaliException e) {
13600       {
13601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13602       };
13603     } catch (...) {
13604       {
13605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13606       };
13607     }
13608   }
13609
13610   jresult = (void *)result;
13611   return jresult;
13612 }
13613
13614
13615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13616   unsigned int jresult ;
13617   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13618   Dali::Matrix3 *arg2 = 0 ;
13619   bool result;
13620
13621   arg1 = (Dali::Matrix3 *)jarg1;
13622   arg2 = (Dali::Matrix3 *)jarg2;
13623   if (!arg2) {
13624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13625     return 0;
13626   }
13627   {
13628     try {
13629       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13630     } catch (std::out_of_range& e) {
13631       {
13632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13633       };
13634     } catch (std::exception& e) {
13635       {
13636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13637       };
13638     } catch (Dali::DaliException e) {
13639       {
13640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13641       };
13642     } catch (...) {
13643       {
13644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13645       };
13646     }
13647   }
13648
13649   jresult = result;
13650   return jresult;
13651 }
13652
13653
13654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13655   unsigned int jresult ;
13656   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13657   Dali::Matrix3 *arg2 = 0 ;
13658   bool result;
13659
13660   arg1 = (Dali::Matrix3 *)jarg1;
13661   arg2 = (Dali::Matrix3 *)jarg2;
13662   if (!arg2) {
13663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13664     return 0;
13665   }
13666   {
13667     try {
13668       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13669     } catch (std::out_of_range& e) {
13670       {
13671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13672       };
13673     } catch (std::exception& e) {
13674       {
13675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13676       };
13677     } catch (Dali::DaliException e) {
13678       {
13679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13680       };
13681     } catch (...) {
13682       {
13683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13684       };
13685     }
13686   }
13687
13688   jresult = result;
13689   return jresult;
13690 }
13691
13692
13693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13694   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13695
13696   arg1 = (Dali::Matrix3 *)jarg1;
13697   {
13698     try {
13699       delete arg1;
13700     } catch (std::out_of_range& e) {
13701       {
13702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13703       };
13704     } catch (std::exception& e) {
13705       {
13706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13707       };
13708     } catch (Dali::DaliException e) {
13709       {
13710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13711       };
13712     } catch (...) {
13713       {
13714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13715       };
13716     }
13717   }
13718
13719 }
13720
13721
13722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13723   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13724
13725   arg1 = (Dali::Matrix3 *)jarg1;
13726   {
13727     try {
13728       (arg1)->SetIdentity();
13729     } catch (std::out_of_range& e) {
13730       {
13731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13732       };
13733     } catch (std::exception& e) {
13734       {
13735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13736       };
13737     } catch (Dali::DaliException e) {
13738       {
13739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13740       };
13741     } catch (...) {
13742       {
13743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13744       };
13745     }
13746   }
13747
13748 }
13749
13750
13751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13752   void * jresult ;
13753   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13754   float *result = 0 ;
13755
13756   arg1 = (Dali::Matrix3 *)jarg1;
13757   {
13758     try {
13759       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13760     } catch (std::out_of_range& e) {
13761       {
13762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13763       };
13764     } catch (std::exception& e) {
13765       {
13766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13767       };
13768     } catch (Dali::DaliException e) {
13769       {
13770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13771       };
13772     } catch (...) {
13773       {
13774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13775       };
13776     }
13777   }
13778
13779   jresult = (void *)result;
13780   return jresult;
13781 }
13782
13783
13784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13785   unsigned int jresult ;
13786   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13787   bool result;
13788
13789   arg1 = (Dali::Matrix3 *)jarg1;
13790   {
13791     try {
13792       result = (bool)(arg1)->Invert();
13793     } catch (std::out_of_range& e) {
13794       {
13795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13796       };
13797     } catch (std::exception& e) {
13798       {
13799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13800       };
13801     } catch (Dali::DaliException e) {
13802       {
13803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13804       };
13805     } catch (...) {
13806       {
13807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13808       };
13809     }
13810   }
13811
13812   jresult = result;
13813   return jresult;
13814 }
13815
13816
13817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13818   unsigned int jresult ;
13819   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13820   bool result;
13821
13822   arg1 = (Dali::Matrix3 *)jarg1;
13823   {
13824     try {
13825       result = (bool)(arg1)->Transpose();
13826     } catch (std::out_of_range& e) {
13827       {
13828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13829       };
13830     } catch (std::exception& e) {
13831       {
13832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13833       };
13834     } catch (Dali::DaliException e) {
13835       {
13836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13837       };
13838     } catch (...) {
13839       {
13840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13841       };
13842     }
13843   }
13844
13845   jresult = result;
13846   return jresult;
13847 }
13848
13849
13850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13851   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13852   float arg2 ;
13853
13854   arg1 = (Dali::Matrix3 *)jarg1;
13855   arg2 = (float)jarg2;
13856   {
13857     try {
13858       (arg1)->Scale(arg2);
13859     } catch (std::out_of_range& e) {
13860       {
13861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13862       };
13863     } catch (std::exception& e) {
13864       {
13865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13866       };
13867     } catch (Dali::DaliException e) {
13868       {
13869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13870       };
13871     } catch (...) {
13872       {
13873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13874       };
13875     }
13876   }
13877
13878 }
13879
13880
13881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13882   float jresult ;
13883   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13884   float result;
13885
13886   arg1 = (Dali::Matrix3 *)jarg1;
13887   {
13888     try {
13889       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13890     } catch (std::out_of_range& e) {
13891       {
13892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13893       };
13894     } catch (std::exception& e) {
13895       {
13896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13897       };
13898     } catch (Dali::DaliException e) {
13899       {
13900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13901       };
13902     } catch (...) {
13903       {
13904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13905       };
13906     }
13907   }
13908
13909   jresult = result;
13910   return jresult;
13911 }
13912
13913
13914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13915   unsigned int jresult ;
13916   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13917   bool result;
13918
13919   arg1 = (Dali::Matrix3 *)jarg1;
13920   {
13921     try {
13922       result = (bool)(arg1)->ScaledInverseTranspose();
13923     } catch (std::out_of_range& e) {
13924       {
13925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13926       };
13927     } catch (std::exception& e) {
13928       {
13929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13930       };
13931     } catch (Dali::DaliException e) {
13932       {
13933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13934       };
13935     } catch (...) {
13936       {
13937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13938       };
13939     }
13940   }
13941
13942   jresult = result;
13943   return jresult;
13944 }
13945
13946
13947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13948   Dali::Matrix3 *arg1 = 0 ;
13949   Dali::Matrix3 *arg2 = 0 ;
13950   Dali::Matrix3 *arg3 = 0 ;
13951
13952   arg1 = (Dali::Matrix3 *)jarg1;
13953   if (!arg1) {
13954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13955     return ;
13956   }
13957   arg2 = (Dali::Matrix3 *)jarg2;
13958   if (!arg2) {
13959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13960     return ;
13961   }
13962   arg3 = (Dali::Matrix3 *)jarg3;
13963   if (!arg3) {
13964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13965     return ;
13966   }
13967   {
13968     try {
13969       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13970     } catch (std::out_of_range& e) {
13971       {
13972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13973       };
13974     } catch (std::exception& e) {
13975       {
13976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13977       };
13978     } catch (Dali::DaliException e) {
13979       {
13980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13981       };
13982     } catch (...) {
13983       {
13984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13985       };
13986     }
13987   }
13988
13989 }
13990
13991
13992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13993   float jresult ;
13994   float arg1 ;
13995   float arg2 ;
13996   float result;
13997
13998   arg1 = (float)jarg1;
13999   arg2 = (float)jarg2;
14000   {
14001     try {
14002       result = (float)Dali::Random::Range(arg1,arg2);
14003     } catch (std::out_of_range& e) {
14004       {
14005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14006       };
14007     } catch (std::exception& e) {
14008       {
14009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14010       };
14011     } catch (Dali::DaliException e) {
14012       {
14013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14014       };
14015     } catch (...) {
14016       {
14017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14018       };
14019     }
14020   }
14021
14022   jresult = result;
14023   return jresult;
14024 }
14025
14026
14027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14028   void * jresult ;
14029   Dali::Vector4 result;
14030
14031   {
14032     try {
14033       result = Dali::Random::Axis();
14034     } catch (std::out_of_range& e) {
14035       {
14036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14037       };
14038     } catch (std::exception& e) {
14039       {
14040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14041       };
14042     } catch (Dali::DaliException e) {
14043       {
14044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14045       };
14046     } catch (...) {
14047       {
14048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14049       };
14050     }
14051   }
14052
14053   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14054   return jresult;
14055 }
14056
14057
14058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14059   void * jresult ;
14060   Dali::AngleAxis *result = 0 ;
14061
14062   {
14063     try {
14064       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14065     } catch (std::out_of_range& e) {
14066       {
14067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14068       };
14069     } catch (std::exception& e) {
14070       {
14071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14072       };
14073     } catch (Dali::DaliException e) {
14074       {
14075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14076       };
14077     } catch (...) {
14078       {
14079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14080       };
14081     }
14082   }
14083
14084   jresult = (void *)result;
14085   return jresult;
14086 }
14087
14088
14089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14090   void * jresult ;
14091   Dali::Radian arg1 ;
14092   Dali::Vector3 *arg2 = 0 ;
14093   Dali::Radian *argp1 ;
14094   Dali::AngleAxis *result = 0 ;
14095
14096   argp1 = (Dali::Radian *)jarg1;
14097   if (!argp1) {
14098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14099     return 0;
14100   }
14101   arg1 = *argp1;
14102   arg2 = (Dali::Vector3 *)jarg2;
14103   if (!arg2) {
14104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14105     return 0;
14106   }
14107   {
14108     try {
14109       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14110     } catch (std::out_of_range& e) {
14111       {
14112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14113       };
14114     } catch (std::exception& e) {
14115       {
14116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14117       };
14118     } catch (Dali::DaliException e) {
14119       {
14120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14121       };
14122     } catch (...) {
14123       {
14124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14125       };
14126     }
14127   }
14128
14129   jresult = (void *)result;
14130   return jresult;
14131 }
14132
14133
14134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14135   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14136   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14137
14138   arg1 = (Dali::AngleAxis *)jarg1;
14139   arg2 = (Dali::Radian *)jarg2;
14140   if (arg1) (arg1)->angle = *arg2;
14141 }
14142
14143
14144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14145   void * jresult ;
14146   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14147   Dali::Radian *result = 0 ;
14148
14149   arg1 = (Dali::AngleAxis *)jarg1;
14150   result = (Dali::Radian *)& ((arg1)->angle);
14151   jresult = (void *)result;
14152   return jresult;
14153 }
14154
14155
14156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14157   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14158   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14159
14160   arg1 = (Dali::AngleAxis *)jarg1;
14161   arg2 = (Dali::Vector3 *)jarg2;
14162   if (arg1) (arg1)->axis = *arg2;
14163 }
14164
14165
14166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14167   void * jresult ;
14168   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14169   Dali::Vector3 *result = 0 ;
14170
14171   arg1 = (Dali::AngleAxis *)jarg1;
14172   result = (Dali::Vector3 *)& ((arg1)->axis);
14173   jresult = (void *)result;
14174   return jresult;
14175 }
14176
14177
14178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14179   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14180
14181   arg1 = (Dali::AngleAxis *)jarg1;
14182   {
14183     try {
14184       delete arg1;
14185     } catch (std::out_of_range& e) {
14186       {
14187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14188       };
14189     } catch (std::exception& e) {
14190       {
14191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14192       };
14193     } catch (Dali::DaliException e) {
14194       {
14195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14196       };
14197     } catch (...) {
14198       {
14199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14200       };
14201     }
14202   }
14203
14204 }
14205
14206
14207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14208   unsigned int jresult ;
14209   Dali::AngleAxis *arg1 = 0 ;
14210   Dali::AngleAxis *arg2 = 0 ;
14211   bool result;
14212
14213   arg1 = (Dali::AngleAxis *)jarg1;
14214   if (!arg1) {
14215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14216     return 0;
14217   }
14218   arg2 = (Dali::AngleAxis *)jarg2;
14219   if (!arg2) {
14220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14221     return 0;
14222   }
14223   {
14224     try {
14225       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14226     } catch (std::out_of_range& e) {
14227       {
14228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14229       };
14230     } catch (std::exception& e) {
14231       {
14232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14233       };
14234     } catch (Dali::DaliException e) {
14235       {
14236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14237       };
14238     } catch (...) {
14239       {
14240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14241       };
14242     }
14243   }
14244
14245   jresult = result;
14246   return jresult;
14247 }
14248
14249
14250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14251   unsigned int jresult ;
14252   unsigned int arg1 ;
14253   unsigned int result;
14254
14255   arg1 = (unsigned int)jarg1;
14256   {
14257     try {
14258       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14259     } catch (std::out_of_range& e) {
14260       {
14261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14262       };
14263     } catch (std::exception& e) {
14264       {
14265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14266       };
14267     } catch (Dali::DaliException e) {
14268       {
14269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14270       };
14271     } catch (...) {
14272       {
14273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14274       };
14275     }
14276   }
14277
14278   jresult = result;
14279   return jresult;
14280 }
14281
14282
14283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14284   unsigned int jresult ;
14285   unsigned int arg1 ;
14286   bool result;
14287
14288   arg1 = (unsigned int)jarg1;
14289   {
14290     try {
14291       result = (bool)Dali::IsPowerOfTwo(arg1);
14292     } catch (std::out_of_range& e) {
14293       {
14294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14295       };
14296     } catch (std::exception& e) {
14297       {
14298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14299       };
14300     } catch (Dali::DaliException e) {
14301       {
14302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14303       };
14304     } catch (...) {
14305       {
14306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14307       };
14308     }
14309   }
14310
14311   jresult = result;
14312   return jresult;
14313 }
14314
14315
14316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14317   float jresult ;
14318   float arg1 ;
14319   float arg2 ;
14320   float result;
14321
14322   arg1 = (float)jarg1;
14323   arg2 = (float)jarg2;
14324   {
14325     try {
14326       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14327     } catch (std::out_of_range& e) {
14328       {
14329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14330       };
14331     } catch (std::exception& e) {
14332       {
14333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14334       };
14335     } catch (Dali::DaliException e) {
14336       {
14337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14338       };
14339     } catch (...) {
14340       {
14341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14342       };
14343     }
14344   }
14345
14346   jresult = result;
14347   return jresult;
14348 }
14349
14350
14351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14352   unsigned int jresult ;
14353   float arg1 ;
14354   bool result;
14355
14356   arg1 = (float)jarg1;
14357   {
14358     try {
14359       result = (bool)Dali::EqualsZero(arg1);
14360     } catch (std::out_of_range& e) {
14361       {
14362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14363       };
14364     } catch (std::exception& e) {
14365       {
14366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14367       };
14368     } catch (Dali::DaliException e) {
14369       {
14370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14371       };
14372     } catch (...) {
14373       {
14374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14375       };
14376     }
14377   }
14378
14379   jresult = result;
14380   return jresult;
14381 }
14382
14383
14384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14385   unsigned int jresult ;
14386   float arg1 ;
14387   float arg2 ;
14388   bool result;
14389
14390   arg1 = (float)jarg1;
14391   arg2 = (float)jarg2;
14392   {
14393     try {
14394       result = (bool)Dali::Equals(arg1,arg2);
14395     } catch (std::out_of_range& e) {
14396       {
14397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14398       };
14399     } catch (std::exception& e) {
14400       {
14401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14402       };
14403     } catch (Dali::DaliException e) {
14404       {
14405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14406       };
14407     } catch (...) {
14408       {
14409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14410       };
14411     }
14412   }
14413
14414   jresult = result;
14415   return jresult;
14416 }
14417
14418
14419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14420   unsigned int jresult ;
14421   float arg1 ;
14422   float arg2 ;
14423   float arg3 ;
14424   bool result;
14425
14426   arg1 = (float)jarg1;
14427   arg2 = (float)jarg2;
14428   arg3 = (float)jarg3;
14429   {
14430     try {
14431       result = (bool)Dali::Equals(arg1,arg2,arg3);
14432     } catch (std::out_of_range& e) {
14433       {
14434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14435       };
14436     } catch (std::exception& e) {
14437       {
14438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14439       };
14440     } catch (Dali::DaliException e) {
14441       {
14442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14443       };
14444     } catch (...) {
14445       {
14446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14447       };
14448     }
14449   }
14450
14451   jresult = result;
14452   return jresult;
14453 }
14454
14455
14456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14457   float jresult ;
14458   float arg1 ;
14459   int arg2 ;
14460   float result;
14461
14462   arg1 = (float)jarg1;
14463   arg2 = (int)jarg2;
14464   {
14465     try {
14466       result = (float)Dali::Round(arg1,arg2);
14467     } catch (std::out_of_range& e) {
14468       {
14469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14470       };
14471     } catch (std::exception& e) {
14472       {
14473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14474       };
14475     } catch (Dali::DaliException e) {
14476       {
14477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14478       };
14479     } catch (...) {
14480       {
14481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14482       };
14483     }
14484   }
14485
14486   jresult = result;
14487   return jresult;
14488 }
14489
14490
14491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14492   float jresult ;
14493   float arg1 ;
14494   float arg2 ;
14495   float arg3 ;
14496   float result;
14497
14498   arg1 = (float)jarg1;
14499   arg2 = (float)jarg2;
14500   arg3 = (float)jarg3;
14501   {
14502     try {
14503       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14504     } catch (std::out_of_range& e) {
14505       {
14506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14507       };
14508     } catch (std::exception& e) {
14509       {
14510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14511       };
14512     } catch (Dali::DaliException e) {
14513       {
14514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14515       };
14516     } catch (...) {
14517       {
14518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14519       };
14520     }
14521   }
14522
14523   jresult = result;
14524   return jresult;
14525 }
14526
14527
14528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14529   float jresult ;
14530   float arg1 ;
14531   float arg2 ;
14532   float arg3 ;
14533   float arg4 ;
14534   float result;
14535
14536   arg1 = (float)jarg1;
14537   arg2 = (float)jarg2;
14538   arg3 = (float)jarg3;
14539   arg4 = (float)jarg4;
14540   {
14541     try {
14542       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14543     } catch (std::out_of_range& e) {
14544       {
14545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14546       };
14547     } catch (std::exception& e) {
14548       {
14549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14550       };
14551     } catch (Dali::DaliException e) {
14552       {
14553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14554       };
14555     } catch (...) {
14556       {
14557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14558       };
14559     }
14560   }
14561
14562   jresult = result;
14563   return jresult;
14564 }
14565
14566
14567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14568   int jresult ;
14569   int result;
14570
14571   result = (int)(int)Dali::Property::INVALID_INDEX;
14572   jresult = result;
14573   return jresult;
14574 }
14575
14576
14577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14578   int jresult ;
14579   int result;
14580
14581   result = (int)(int)Dali::Property::INVALID_KEY;
14582   jresult = result;
14583   return jresult;
14584 }
14585
14586
14587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14588   int jresult ;
14589   int result;
14590
14591   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14592   jresult = result;
14593   return jresult;
14594 }
14595
14596
14597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14598   void * jresult ;
14599   Dali::Handle *arg1 = 0 ;
14600   Dali::Property::Index arg2 ;
14601   Dali::Property *result = 0 ;
14602
14603   arg1 = (Dali::Handle *)jarg1;
14604   if (!arg1) {
14605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14606     return 0;
14607   }
14608   arg2 = (Dali::Property::Index)jarg2;
14609   {
14610     try {
14611       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14612     } catch (std::out_of_range& e) {
14613       {
14614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14615       };
14616     } catch (std::exception& e) {
14617       {
14618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14619       };
14620     } catch (Dali::DaliException e) {
14621       {
14622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14623       };
14624     } catch (...) {
14625       {
14626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14627       };
14628     }
14629   }
14630
14631   jresult = (void *)result;
14632   return jresult;
14633 }
14634
14635
14636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14637   void * jresult ;
14638   Dali::Handle *arg1 = 0 ;
14639   Dali::Property::Index arg2 ;
14640   int arg3 ;
14641   Dali::Property *result = 0 ;
14642
14643   arg1 = (Dali::Handle *)jarg1;
14644   if (!arg1) {
14645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14646     return 0;
14647   }
14648   arg2 = (Dali::Property::Index)jarg2;
14649   arg3 = (int)jarg3;
14650   {
14651     try {
14652       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14653     } catch (std::out_of_range& e) {
14654       {
14655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14656       };
14657     } catch (std::exception& e) {
14658       {
14659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14660       };
14661     } catch (Dali::DaliException e) {
14662       {
14663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14664       };
14665     } catch (...) {
14666       {
14667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14668       };
14669     }
14670   }
14671
14672   jresult = (void *)result;
14673   return jresult;
14674 }
14675
14676
14677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14678   void * jresult ;
14679   Dali::Handle *arg1 = 0 ;
14680   std::string *arg2 = 0 ;
14681   Dali::Property *result = 0 ;
14682
14683   arg1 = (Dali::Handle *)jarg1;
14684   if (!arg1) {
14685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14686     return 0;
14687   }
14688   if (!jarg2) {
14689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14690     return 0;
14691   }
14692   std::string arg2_str(jarg2);
14693   arg2 = &arg2_str;
14694   {
14695     try {
14696       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14697     } catch (std::out_of_range& e) {
14698       {
14699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14700       };
14701     } catch (std::exception& e) {
14702       {
14703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14704       };
14705     } catch (Dali::DaliException e) {
14706       {
14707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14708       };
14709     } catch (...) {
14710       {
14711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14712       };
14713     }
14714   }
14715
14716   jresult = (void *)result;
14717
14718   //argout typemap for const std::string&
14719
14720   return jresult;
14721 }
14722
14723
14724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14725   void * jresult ;
14726   Dali::Handle *arg1 = 0 ;
14727   std::string *arg2 = 0 ;
14728   int arg3 ;
14729   Dali::Property *result = 0 ;
14730
14731   arg1 = (Dali::Handle *)jarg1;
14732   if (!arg1) {
14733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14734     return 0;
14735   }
14736   if (!jarg2) {
14737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14738     return 0;
14739   }
14740   std::string arg2_str(jarg2);
14741   arg2 = &arg2_str;
14742   arg3 = (int)jarg3;
14743   {
14744     try {
14745       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14746     } catch (std::out_of_range& e) {
14747       {
14748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14749       };
14750     } catch (std::exception& e) {
14751       {
14752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14753       };
14754     } catch (Dali::DaliException e) {
14755       {
14756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14757       };
14758     } catch (...) {
14759       {
14760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14761       };
14762     }
14763   }
14764
14765   jresult = (void *)result;
14766
14767   //argout typemap for const std::string&
14768
14769   return jresult;
14770 }
14771
14772
14773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14774   Dali::Property *arg1 = (Dali::Property *) 0 ;
14775
14776   arg1 = (Dali::Property *)jarg1;
14777   {
14778     try {
14779       delete arg1;
14780     } catch (std::out_of_range& e) {
14781       {
14782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14783       };
14784     } catch (std::exception& e) {
14785       {
14786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14787       };
14788     } catch (Dali::DaliException e) {
14789       {
14790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14791       };
14792     } catch (...) {
14793       {
14794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14795       };
14796     }
14797   }
14798
14799 }
14800
14801
14802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14803   Dali::Property *arg1 = (Dali::Property *) 0 ;
14804   Dali::Handle *arg2 = 0 ;
14805
14806   arg1 = (Dali::Property *)jarg1;
14807   arg2 = (Dali::Handle *)jarg2;
14808   if (!arg2) {
14809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14810     return ;
14811   }
14812   if (arg1) (arg1)->object = *arg2;
14813 }
14814
14815
14816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14817   void * jresult ;
14818   Dali::Property *arg1 = (Dali::Property *) 0 ;
14819   Dali::Handle *result = 0 ;
14820
14821   arg1 = (Dali::Property *)jarg1;
14822   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14823   jresult = (void *)result;
14824   return jresult;
14825 }
14826
14827
14828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14829   Dali::Property *arg1 = (Dali::Property *) 0 ;
14830   Dali::Property::Index arg2 ;
14831
14832   arg1 = (Dali::Property *)jarg1;
14833   arg2 = (Dali::Property::Index)jarg2;
14834   if (arg1) (arg1)->propertyIndex = arg2;
14835 }
14836
14837
14838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14839   int jresult ;
14840   Dali::Property *arg1 = (Dali::Property *) 0 ;
14841   Dali::Property::Index result;
14842
14843   arg1 = (Dali::Property *)jarg1;
14844   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14845   jresult = result;
14846   return jresult;
14847 }
14848
14849
14850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14851   Dali::Property *arg1 = (Dali::Property *) 0 ;
14852   int arg2 ;
14853
14854   arg1 = (Dali::Property *)jarg1;
14855   arg2 = (int)jarg2;
14856   if (arg1) (arg1)->componentIndex = arg2;
14857 }
14858
14859
14860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14861   int jresult ;
14862   Dali::Property *arg1 = (Dali::Property *) 0 ;
14863   int result;
14864
14865   arg1 = (Dali::Property *)jarg1;
14866   result = (int) ((arg1)->componentIndex);
14867   jresult = result;
14868   return jresult;
14869 }
14870
14871
14872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14873   void * jresult ;
14874   Dali::Property::Array *result = 0 ;
14875
14876   {
14877     try {
14878       result = (Dali::Property::Array *)new Dali::Property::Array();
14879     } catch (std::out_of_range& e) {
14880       {
14881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14882       };
14883     } catch (std::exception& e) {
14884       {
14885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14886       };
14887     } catch (Dali::DaliException e) {
14888       {
14889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14890       };
14891     } catch (...) {
14892       {
14893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14894       };
14895     }
14896   }
14897
14898   jresult = (void *)result;
14899   return jresult;
14900 }
14901
14902
14903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14904   void * jresult ;
14905   Dali::Property::Array *arg1 = 0 ;
14906   Dali::Property::Array *result = 0 ;
14907
14908   arg1 = (Dali::Property::Array *)jarg1;
14909   if (!arg1) {
14910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14911     return 0;
14912   }
14913   {
14914     try {
14915       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14916     } catch (std::out_of_range& e) {
14917       {
14918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14919       };
14920     } catch (std::exception& e) {
14921       {
14922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14923       };
14924     } catch (Dali::DaliException e) {
14925       {
14926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14927       };
14928     } catch (...) {
14929       {
14930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14931       };
14932     }
14933   }
14934
14935   jresult = (void *)result;
14936   return jresult;
14937 }
14938
14939
14940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14941   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14942
14943   arg1 = (Dali::Property::Array *)jarg1;
14944   {
14945     try {
14946       delete arg1;
14947     } catch (std::out_of_range& e) {
14948       {
14949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14950       };
14951     } catch (std::exception& e) {
14952       {
14953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14954       };
14955     } catch (Dali::DaliException e) {
14956       {
14957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14958       };
14959     } catch (...) {
14960       {
14961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14962       };
14963     }
14964   }
14965
14966 }
14967
14968
14969 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14970   unsigned long jresult ;
14971   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14972   Dali::Property::Array::SizeType result;
14973
14974   arg1 = (Dali::Property::Array *)jarg1;
14975   {
14976     try {
14977       result = ((Dali::Property::Array const *)arg1)->Size();
14978     } catch (std::out_of_range& e) {
14979       {
14980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14981       };
14982     } catch (std::exception& e) {
14983       {
14984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14985       };
14986     } catch (Dali::DaliException e) {
14987       {
14988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14989       };
14990     } catch (...) {
14991       {
14992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14993       };
14994     }
14995   }
14996
14997   jresult = (unsigned long)result;
14998   return jresult;
14999 }
15000
15001
15002 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15003   unsigned long jresult ;
15004   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15005   Dali::Property::Array::SizeType result;
15006
15007   arg1 = (Dali::Property::Array *)jarg1;
15008   {
15009     try {
15010       result = ((Dali::Property::Array const *)arg1)->Count();
15011     } catch (std::out_of_range& e) {
15012       {
15013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15014       };
15015     } catch (std::exception& e) {
15016       {
15017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15018       };
15019     } catch (Dali::DaliException e) {
15020       {
15021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15022       };
15023     } catch (...) {
15024       {
15025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15026       };
15027     }
15028   }
15029
15030   jresult = (unsigned long)result;
15031   return jresult;
15032 }
15033
15034
15035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15036   unsigned int jresult ;
15037   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15038   bool result;
15039
15040   arg1 = (Dali::Property::Array *)jarg1;
15041   {
15042     try {
15043       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15044     } catch (std::out_of_range& e) {
15045       {
15046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15047       };
15048     } catch (std::exception& e) {
15049       {
15050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15051       };
15052     } catch (Dali::DaliException e) {
15053       {
15054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15055       };
15056     } catch (...) {
15057       {
15058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15059       };
15060     }
15061   }
15062
15063   jresult = result;
15064   return jresult;
15065 }
15066
15067
15068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15069   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15070
15071   arg1 = (Dali::Property::Array *)jarg1;
15072   {
15073     try {
15074       (arg1)->Clear();
15075     } catch (std::out_of_range& e) {
15076       {
15077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15078       };
15079     } catch (std::exception& e) {
15080       {
15081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15082       };
15083     } catch (Dali::DaliException e) {
15084       {
15085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15086       };
15087     } catch (...) {
15088       {
15089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15090       };
15091     }
15092   }
15093
15094 }
15095
15096
15097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15098   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15099   Dali::Property::Array::SizeType arg2 ;
15100
15101   arg1 = (Dali::Property::Array *)jarg1;
15102   arg2 = (Dali::Property::Array::SizeType)jarg2;
15103   {
15104     try {
15105       (arg1)->Reserve(arg2);
15106     } catch (std::out_of_range& e) {
15107       {
15108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15109       };
15110     } catch (std::exception& e) {
15111       {
15112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15113       };
15114     } catch (Dali::DaliException e) {
15115       {
15116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15117       };
15118     } catch (...) {
15119       {
15120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15121       };
15122     }
15123   }
15124
15125 }
15126
15127
15128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15129   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15130   Dali::Property::Array::SizeType arg2 ;
15131
15132   arg1 = (Dali::Property::Array *)jarg1;
15133   arg2 = (Dali::Property::Array::SizeType)jarg2;
15134   {
15135     try {
15136       (arg1)->Resize(arg2);
15137     } catch (std::out_of_range& e) {
15138       {
15139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15140       };
15141     } catch (std::exception& e) {
15142       {
15143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15144       };
15145     } catch (Dali::DaliException e) {
15146       {
15147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15148       };
15149     } catch (...) {
15150       {
15151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15152       };
15153     }
15154   }
15155
15156 }
15157
15158
15159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15160   unsigned long jresult ;
15161   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15162   Dali::Property::Array::SizeType result;
15163
15164   arg1 = (Dali::Property::Array *)jarg1;
15165   {
15166     try {
15167       result = (arg1)->Capacity();
15168     } catch (std::out_of_range& e) {
15169       {
15170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15171       };
15172     } catch (std::exception& e) {
15173       {
15174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15175       };
15176     } catch (Dali::DaliException e) {
15177       {
15178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15179       };
15180     } catch (...) {
15181       {
15182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15183       };
15184     }
15185   }
15186
15187   jresult = (unsigned long)result;
15188   return jresult;
15189 }
15190
15191
15192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15193   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15194   Dali::Property::Value *arg2 = 0 ;
15195
15196   arg1 = (Dali::Property::Array *)jarg1;
15197   arg2 = (Dali::Property::Value *)jarg2;
15198   if (!arg2) {
15199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15200     return ;
15201   }
15202   {
15203     try {
15204       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15205     } catch (std::out_of_range& e) {
15206       {
15207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15208       };
15209     } catch (std::exception& e) {
15210       {
15211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15212       };
15213     } catch (Dali::DaliException e) {
15214       {
15215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15216       };
15217     } catch (...) {
15218       {
15219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15220       };
15221     }
15222   }
15223
15224 }
15225
15226
15227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15228   void * jresult ;
15229   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15230   Dali::Property::Value *arg2 = 0 ;
15231   Dali::Property::Array *result = 0 ;
15232
15233   arg1 = (Dali::Property::Array *)jarg1;
15234   arg2 = (Dali::Property::Value *)jarg2;
15235   if (!arg2) {
15236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15237     return 0;
15238   }
15239   {
15240     try {
15241       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15242     } catch (std::out_of_range& e) {
15243       {
15244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15245       };
15246     } catch (std::exception& e) {
15247       {
15248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15249       };
15250     } catch (Dali::DaliException e) {
15251       {
15252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15253       };
15254     } catch (...) {
15255       {
15256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15257       };
15258     }
15259   }
15260
15261   jresult = (void *)result;
15262   return jresult;
15263 }
15264
15265
15266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15267   void * jresult ;
15268   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15269   Dali::Property::Array::SizeType arg2 ;
15270   Dali::Property::Value *result = 0 ;
15271
15272   arg1 = (Dali::Property::Array *)jarg1;
15273   arg2 = (Dali::Property::Array::SizeType)jarg2;
15274   {
15275     try {
15276       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15277     } catch (std::out_of_range& e) {
15278       {
15279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15280       };
15281     } catch (std::exception& e) {
15282       {
15283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15284       };
15285     } catch (Dali::DaliException e) {
15286       {
15287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15288       };
15289     } catch (...) {
15290       {
15291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15292       };
15293     }
15294   }
15295
15296   jresult = (void *)result;
15297   return jresult;
15298 }
15299
15300
15301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15302   void * jresult ;
15303   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15304   Dali::Property::Array::SizeType arg2 ;
15305   Dali::Property::Value *result = 0 ;
15306
15307   arg1 = (Dali::Property::Array *)jarg1;
15308   arg2 = (Dali::Property::Array::SizeType)jarg2;
15309   {
15310     try {
15311       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15312     } catch (std::out_of_range& e) {
15313       {
15314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15315       };
15316     } catch (std::exception& e) {
15317       {
15318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15319       };
15320     } catch (Dali::DaliException e) {
15321       {
15322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15323       };
15324     } catch (...) {
15325       {
15326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15327       };
15328     }
15329   }
15330
15331   jresult = (void *)result;
15332   return jresult;
15333 }
15334
15335
15336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15337   void * jresult ;
15338   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15339   Dali::Property::Array *arg2 = 0 ;
15340   Dali::Property::Array *result = 0 ;
15341
15342   arg1 = (Dali::Property::Array *)jarg1;
15343   arg2 = (Dali::Property::Array *)jarg2;
15344   if (!arg2) {
15345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15346     return 0;
15347   }
15348   {
15349     try {
15350       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15351     } catch (std::out_of_range& e) {
15352       {
15353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15354       };
15355     } catch (std::exception& e) {
15356       {
15357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15358       };
15359     } catch (Dali::DaliException e) {
15360       {
15361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15362       };
15363     } catch (...) {
15364       {
15365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15366       };
15367     }
15368   }
15369
15370   jresult = (void *)result;
15371   return jresult;
15372 }
15373
15374
15375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15376   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15377   enum Dali::Property::Key::Type arg2 ;
15378
15379   arg1 = (Dali::Property::Key *)jarg1;
15380   arg2 = (enum Dali::Property::Key::Type)jarg2;
15381   if (arg1) (arg1)->type = arg2;
15382 }
15383
15384
15385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15386   int jresult ;
15387   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15388   enum Dali::Property::Key::Type result;
15389
15390   arg1 = (Dali::Property::Key *)jarg1;
15391   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15392   jresult = (int)result;
15393   return jresult;
15394 }
15395
15396
15397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15398   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15399   Dali::Property::Index arg2 ;
15400
15401   arg1 = (Dali::Property::Key *)jarg1;
15402   arg2 = (Dali::Property::Index)jarg2;
15403   if (arg1) (arg1)->indexKey = arg2;
15404 }
15405
15406
15407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15408   int jresult ;
15409   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15410   Dali::Property::Index result;
15411
15412   arg1 = (Dali::Property::Key *)jarg1;
15413   result = (Dali::Property::Index) ((arg1)->indexKey);
15414   jresult = result;
15415   return jresult;
15416 }
15417
15418
15419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15420   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15421   std::string *arg2 = 0 ;
15422
15423   arg1 = (Dali::Property::Key *)jarg1;
15424   if (!jarg2) {
15425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15426     return ;
15427   }
15428   std::string arg2_str(jarg2);
15429   arg2 = &arg2_str;
15430   if (arg1) (arg1)->stringKey = *arg2;
15431
15432   //argout typemap for const std::string&
15433
15434 }
15435
15436
15437 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15438   char * jresult ;
15439   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15440   std::string *result = 0 ;
15441
15442   arg1 = (Dali::Property::Key *)jarg1;
15443   result = (std::string *) & ((arg1)->stringKey);
15444   jresult = SWIG_csharp_string_callback(result->c_str());
15445   return jresult;
15446 }
15447
15448
15449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15450   void * jresult ;
15451   std::string *arg1 = 0 ;
15452   Dali::Property::Key *result = 0 ;
15453
15454   if (!jarg1) {
15455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15456     return 0;
15457   }
15458   std::string arg1_str(jarg1);
15459   arg1 = &arg1_str;
15460   {
15461     try {
15462       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15463     } catch (std::out_of_range& e) {
15464       {
15465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15466       };
15467     } catch (std::exception& e) {
15468       {
15469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15470       };
15471     } catch (Dali::DaliException e) {
15472       {
15473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15474       };
15475     } catch (...) {
15476       {
15477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15478       };
15479     }
15480   }
15481
15482   jresult = (void *)result;
15483
15484   //argout typemap for const std::string&
15485
15486   return jresult;
15487 }
15488
15489
15490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15491   void * jresult ;
15492   Dali::Property::Index arg1 ;
15493   Dali::Property::Key *result = 0 ;
15494
15495   arg1 = (Dali::Property::Index)jarg1;
15496   {
15497     try {
15498       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15499     } catch (std::out_of_range& e) {
15500       {
15501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15502       };
15503     } catch (std::exception& e) {
15504       {
15505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15506       };
15507     } catch (Dali::DaliException e) {
15508       {
15509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15510       };
15511     } catch (...) {
15512       {
15513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15514       };
15515     }
15516   }
15517
15518   jresult = (void *)result;
15519   return jresult;
15520 }
15521
15522
15523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15524   unsigned int jresult ;
15525   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15526   std::string *arg2 = 0 ;
15527   bool result;
15528
15529   arg1 = (Dali::Property::Key *)jarg1;
15530   if (!jarg2) {
15531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15532     return 0;
15533   }
15534   std::string arg2_str(jarg2);
15535   arg2 = &arg2_str;
15536   {
15537     try {
15538       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15539     } catch (std::out_of_range& e) {
15540       {
15541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15542       };
15543     } catch (std::exception& e) {
15544       {
15545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15546       };
15547     } catch (Dali::DaliException e) {
15548       {
15549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15550       };
15551     } catch (...) {
15552       {
15553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15554       };
15555     }
15556   }
15557
15558   jresult = result;
15559
15560   //argout typemap for const std::string&
15561
15562   return jresult;
15563 }
15564
15565
15566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15567   unsigned int jresult ;
15568   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15569   Dali::Property::Index arg2 ;
15570   bool result;
15571
15572   arg1 = (Dali::Property::Key *)jarg1;
15573   arg2 = (Dali::Property::Index)jarg2;
15574   {
15575     try {
15576       result = (bool)(arg1)->operator ==(arg2);
15577     } catch (std::out_of_range& e) {
15578       {
15579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15580       };
15581     } catch (std::exception& e) {
15582       {
15583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15584       };
15585     } catch (Dali::DaliException e) {
15586       {
15587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15588       };
15589     } catch (...) {
15590       {
15591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15592       };
15593     }
15594   }
15595
15596   jresult = result;
15597   return jresult;
15598 }
15599
15600
15601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15602   unsigned int jresult ;
15603   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15604   Dali::Property::Key *arg2 = 0 ;
15605   bool result;
15606
15607   arg1 = (Dali::Property::Key *)jarg1;
15608   arg2 = (Dali::Property::Key *)jarg2;
15609   if (!arg2) {
15610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15611     return 0;
15612   }
15613   {
15614     try {
15615       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15616     } catch (std::out_of_range& e) {
15617       {
15618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15619       };
15620     } catch (std::exception& e) {
15621       {
15622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15623       };
15624     } catch (Dali::DaliException e) {
15625       {
15626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15627       };
15628     } catch (...) {
15629       {
15630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15631       };
15632     }
15633   }
15634
15635   jresult = result;
15636   return jresult;
15637 }
15638
15639
15640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15641   unsigned int jresult ;
15642   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15643   std::string *arg2 = 0 ;
15644   bool result;
15645
15646   arg1 = (Dali::Property::Key *)jarg1;
15647   if (!jarg2) {
15648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15649     return 0;
15650   }
15651   std::string arg2_str(jarg2);
15652   arg2 = &arg2_str;
15653   {
15654     try {
15655       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15656     } catch (std::out_of_range& e) {
15657       {
15658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15659       };
15660     } catch (std::exception& e) {
15661       {
15662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15663       };
15664     } catch (Dali::DaliException e) {
15665       {
15666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15667       };
15668     } catch (...) {
15669       {
15670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15671       };
15672     }
15673   }
15674
15675   jresult = result;
15676
15677   //argout typemap for const std::string&
15678
15679   return jresult;
15680 }
15681
15682
15683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15684   unsigned int jresult ;
15685   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15686   Dali::Property::Index arg2 ;
15687   bool result;
15688
15689   arg1 = (Dali::Property::Key *)jarg1;
15690   arg2 = (Dali::Property::Index)jarg2;
15691   {
15692     try {
15693       result = (bool)(arg1)->operator !=(arg2);
15694     } catch (std::out_of_range& e) {
15695       {
15696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15697       };
15698     } catch (std::exception& e) {
15699       {
15700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15701       };
15702     } catch (Dali::DaliException e) {
15703       {
15704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15705       };
15706     } catch (...) {
15707       {
15708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15709       };
15710     }
15711   }
15712
15713   jresult = result;
15714   return jresult;
15715 }
15716
15717
15718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15719   unsigned int jresult ;
15720   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15721   Dali::Property::Key *arg2 = 0 ;
15722   bool result;
15723
15724   arg1 = (Dali::Property::Key *)jarg1;
15725   arg2 = (Dali::Property::Key *)jarg2;
15726   if (!arg2) {
15727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15728     return 0;
15729   }
15730   {
15731     try {
15732       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15733     } catch (std::out_of_range& e) {
15734       {
15735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15736       };
15737     } catch (std::exception& e) {
15738       {
15739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15740       };
15741     } catch (Dali::DaliException e) {
15742       {
15743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15744       };
15745     } catch (...) {
15746       {
15747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15748       };
15749     }
15750   }
15751
15752   jresult = result;
15753   return jresult;
15754 }
15755
15756
15757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15758   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15759
15760   arg1 = (Dali::Property::Key *)jarg1;
15761   {
15762     try {
15763       delete arg1;
15764     } catch (std::out_of_range& e) {
15765       {
15766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15767       };
15768     } catch (std::exception& e) {
15769       {
15770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15771       };
15772     } catch (Dali::DaliException e) {
15773       {
15774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15775       };
15776     } catch (...) {
15777       {
15778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15779       };
15780     }
15781   }
15782
15783 }
15784
15785
15786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15787   void * jresult ;
15788   Dali::Property::Map *result = 0 ;
15789
15790   {
15791     try {
15792       result = (Dali::Property::Map *)new Dali::Property::Map();
15793     } catch (std::out_of_range& e) {
15794       {
15795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15796       };
15797     } catch (std::exception& e) {
15798       {
15799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15800       };
15801     } catch (Dali::DaliException e) {
15802       {
15803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15804       };
15805     } catch (...) {
15806       {
15807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15808       };
15809     }
15810   }
15811
15812   jresult = (void *)result;
15813   return jresult;
15814 }
15815
15816
15817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15818   void * jresult ;
15819   Dali::Property::Map *arg1 = 0 ;
15820   Dali::Property::Map *result = 0 ;
15821
15822   arg1 = (Dali::Property::Map *)jarg1;
15823   if (!arg1) {
15824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15825     return 0;
15826   }
15827   {
15828     try {
15829       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15830     } catch (std::out_of_range& e) {
15831       {
15832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15833       };
15834     } catch (std::exception& e) {
15835       {
15836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15837       };
15838     } catch (Dali::DaliException e) {
15839       {
15840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15841       };
15842     } catch (...) {
15843       {
15844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15845       };
15846     }
15847   }
15848
15849   jresult = (void *)result;
15850   return jresult;
15851 }
15852
15853
15854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15855   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15856
15857   arg1 = (Dali::Property::Map *)jarg1;
15858   {
15859     try {
15860       delete arg1;
15861     } catch (std::out_of_range& e) {
15862       {
15863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15864       };
15865     } catch (std::exception& e) {
15866       {
15867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15868       };
15869     } catch (Dali::DaliException e) {
15870       {
15871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15872       };
15873     } catch (...) {
15874       {
15875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15876       };
15877     }
15878   }
15879
15880 }
15881
15882
15883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15884   unsigned long jresult ;
15885   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15886   Dali::Property::Map::SizeType result;
15887
15888   arg1 = (Dali::Property::Map *)jarg1;
15889   {
15890     try {
15891       result = ((Dali::Property::Map const *)arg1)->Count();
15892     } catch (std::out_of_range& e) {
15893       {
15894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15895       };
15896     } catch (std::exception& e) {
15897       {
15898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15899       };
15900     } catch (Dali::DaliException e) {
15901       {
15902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15903       };
15904     } catch (...) {
15905       {
15906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15907       };
15908     }
15909   }
15910
15911   jresult = (unsigned long)result;
15912   return jresult;
15913 }
15914
15915
15916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15917   unsigned int jresult ;
15918   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15919   bool result;
15920
15921   arg1 = (Dali::Property::Map *)jarg1;
15922   {
15923     try {
15924       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15925     } catch (std::out_of_range& e) {
15926       {
15927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15928       };
15929     } catch (std::exception& e) {
15930       {
15931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15932       };
15933     } catch (Dali::DaliException e) {
15934       {
15935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15936       };
15937     } catch (...) {
15938       {
15939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15940       };
15941     }
15942   }
15943
15944   jresult = result;
15945   return jresult;
15946 }
15947
15948
15949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15950   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15951   char *arg2 = (char *) 0 ;
15952   Dali::Property::Value *arg3 = 0 ;
15953
15954   arg1 = (Dali::Property::Map *)jarg1;
15955   arg2 = (char *)jarg2;
15956   arg3 = (Dali::Property::Value *)jarg3;
15957   if (!arg3) {
15958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15959     return ;
15960   }
15961   {
15962     try {
15963       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15964     } catch (std::out_of_range& e) {
15965       {
15966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15967       };
15968     } catch (std::exception& e) {
15969       {
15970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15971       };
15972     } catch (Dali::DaliException e) {
15973       {
15974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15975       };
15976     } catch (...) {
15977       {
15978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15979       };
15980     }
15981   }
15982
15983 }
15984
15985
15986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15987   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15988   Dali::Property::Index arg2 ;
15989   Dali::Property::Value *arg3 = 0 ;
15990
15991   arg1 = (Dali::Property::Map *)jarg1;
15992   arg2 = (Dali::Property::Index)jarg2;
15993   arg3 = (Dali::Property::Value *)jarg3;
15994   if (!arg3) {
15995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15996     return ;
15997   }
15998   {
15999     try {
16000       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16001     } catch (std::out_of_range& e) {
16002       {
16003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16004       };
16005     } catch (std::exception& e) {
16006       {
16007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16008       };
16009     } catch (Dali::DaliException e) {
16010       {
16011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16012       };
16013     } catch (...) {
16014       {
16015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16016       };
16017     }
16018   }
16019
16020 }
16021
16022
16023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16024   void * jresult ;
16025   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16026   char *arg2 = (char *) 0 ;
16027   Dali::Property::Value *arg3 = 0 ;
16028   Dali::Property::Map *result = 0 ;
16029
16030   arg1 = (Dali::Property::Map *)jarg1;
16031   arg2 = (char *)jarg2;
16032   arg3 = (Dali::Property::Value *)jarg3;
16033   if (!arg3) {
16034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16035     return 0;
16036   }
16037   {
16038     try {
16039       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16040     } catch (std::out_of_range& e) {
16041       {
16042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16043       };
16044     } catch (std::exception& e) {
16045       {
16046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16047       };
16048     } catch (Dali::DaliException e) {
16049       {
16050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16051       };
16052     } catch (...) {
16053       {
16054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16055       };
16056     }
16057   }
16058
16059   jresult = (void *)result;
16060   return jresult;
16061 }
16062
16063
16064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16065   void * jresult ;
16066   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16067   Dali::Property::Index arg2 ;
16068   Dali::Property::Value *arg3 = 0 ;
16069   Dali::Property::Map *result = 0 ;
16070
16071   arg1 = (Dali::Property::Map *)jarg1;
16072   arg2 = (Dali::Property::Index)jarg2;
16073   arg3 = (Dali::Property::Value *)jarg3;
16074   if (!arg3) {
16075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16076     return 0;
16077   }
16078   {
16079     try {
16080       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16081     } catch (std::out_of_range& e) {
16082       {
16083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16084       };
16085     } catch (std::exception& e) {
16086       {
16087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16088       };
16089     } catch (Dali::DaliException e) {
16090       {
16091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16092       };
16093     } catch (...) {
16094       {
16095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16096       };
16097     }
16098   }
16099
16100   jresult = (void *)result;
16101   return jresult;
16102 }
16103
16104
16105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16106   void * jresult ;
16107   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16108   Dali::Property::Map::SizeType arg2 ;
16109   Dali::Property::Value *result = 0 ;
16110
16111   arg1 = (Dali::Property::Map *)jarg1;
16112   arg2 = (Dali::Property::Map::SizeType)jarg2;
16113   {
16114     try {
16115       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16116     } catch (std::out_of_range& e) {
16117       {
16118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16119       };
16120     } catch (std::exception& e) {
16121       {
16122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16123       };
16124     } catch (Dali::DaliException e) {
16125       {
16126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16127       };
16128     } catch (...) {
16129       {
16130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16131       };
16132     }
16133   }
16134
16135   jresult = (void *)result;
16136   return jresult;
16137 }
16138
16139
16140 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16141   char * jresult ;
16142   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16143   Dali::Property::Map::SizeType arg2 ;
16144   std::string *result = 0 ;
16145
16146   arg1 = (Dali::Property::Map *)jarg1;
16147   arg2 = (Dali::Property::Map::SizeType)jarg2;
16148   {
16149     try {
16150       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16151     } catch (std::out_of_range& e) {
16152       {
16153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16154       };
16155     } catch (std::exception& e) {
16156       {
16157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16158       };
16159     } catch (Dali::DaliException e) {
16160       {
16161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16162       };
16163     } catch (...) {
16164       {
16165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16166       };
16167     }
16168   }
16169
16170   jresult = SWIG_csharp_string_callback(result->c_str());
16171   return jresult;
16172 }
16173
16174
16175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16176   void * jresult ;
16177   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16178   Dali::Property::Map::SizeType arg2 ;
16179   SwigValueWrapper< Dali::Property::Key > result;
16180
16181   arg1 = (Dali::Property::Map *)jarg1;
16182   arg2 = (Dali::Property::Map::SizeType)jarg2;
16183   {
16184     try {
16185       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16186     } catch (std::out_of_range& e) {
16187       {
16188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16189       };
16190     } catch (std::exception& e) {
16191       {
16192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16193       };
16194     } catch (Dali::DaliException e) {
16195       {
16196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16197       };
16198     } catch (...) {
16199       {
16200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16201       };
16202     }
16203   }
16204
16205   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16206   return jresult;
16207 }
16208
16209
16210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16211   void * jresult ;
16212   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16213   Dali::Property::Map::SizeType arg2 ;
16214   StringValuePair *result = 0 ;
16215
16216   arg1 = (Dali::Property::Map *)jarg1;
16217   arg2 = (Dali::Property::Map::SizeType)jarg2;
16218   {
16219     try {
16220       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16221     } catch (std::out_of_range& e) {
16222       {
16223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16224       };
16225     } catch (std::exception& e) {
16226       {
16227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16228       };
16229     } catch (Dali::DaliException e) {
16230       {
16231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16232       };
16233     } catch (...) {
16234       {
16235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16236       };
16237     }
16238   }
16239
16240   jresult = (void *)result;
16241   return jresult;
16242 }
16243
16244
16245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16246   void * jresult ;
16247   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16248   char *arg2 = (char *) 0 ;
16249   Dali::Property::Value *result = 0 ;
16250
16251   arg1 = (Dali::Property::Map *)jarg1;
16252   arg2 = (char *)jarg2;
16253   {
16254     try {
16255       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16256     } catch (std::out_of_range& e) {
16257       {
16258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16259       };
16260     } catch (std::exception& e) {
16261       {
16262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16263       };
16264     } catch (Dali::DaliException e) {
16265       {
16266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16267       };
16268     } catch (...) {
16269       {
16270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16271       };
16272     }
16273   }
16274
16275   jresult = (void *)result;
16276   return jresult;
16277 }
16278
16279
16280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16281   void * jresult ;
16282   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16283   Dali::Property::Index arg2 ;
16284   Dali::Property::Value *result = 0 ;
16285
16286   arg1 = (Dali::Property::Map *)jarg1;
16287   arg2 = (Dali::Property::Index)jarg2;
16288   {
16289     try {
16290       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16291     } catch (std::out_of_range& e) {
16292       {
16293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16294       };
16295     } catch (std::exception& e) {
16296       {
16297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16298       };
16299     } catch (Dali::DaliException e) {
16300       {
16301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16302       };
16303     } catch (...) {
16304       {
16305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16306       };
16307     }
16308   }
16309
16310   jresult = (void *)result;
16311   return jresult;
16312 }
16313
16314
16315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16316   void * jresult ;
16317   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16318   Dali::Property::Index arg2 ;
16319   std::string *arg3 = 0 ;
16320   Dali::Property::Value *result = 0 ;
16321
16322   arg1 = (Dali::Property::Map *)jarg1;
16323   arg2 = (Dali::Property::Index)jarg2;
16324   if (!jarg3) {
16325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16326     return 0;
16327   }
16328   std::string arg3_str(jarg3);
16329   arg3 = &arg3_str;
16330   {
16331     try {
16332       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16333     } catch (std::out_of_range& e) {
16334       {
16335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16336       };
16337     } catch (std::exception& e) {
16338       {
16339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16340       };
16341     } catch (Dali::DaliException e) {
16342       {
16343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16344       };
16345     } catch (...) {
16346       {
16347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16348       };
16349     }
16350   }
16351
16352   jresult = (void *)result;
16353
16354   //argout typemap for const std::string&
16355
16356   return jresult;
16357 }
16358
16359
16360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16361   void * jresult ;
16362   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16363   std::string *arg2 = 0 ;
16364   Dali::Property::Type arg3 ;
16365   Dali::Property::Value *result = 0 ;
16366
16367   arg1 = (Dali::Property::Map *)jarg1;
16368   if (!jarg2) {
16369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16370     return 0;
16371   }
16372   std::string arg2_str(jarg2);
16373   arg2 = &arg2_str;
16374   arg3 = (Dali::Property::Type)jarg3;
16375   {
16376     try {
16377       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16378     } catch (std::out_of_range& e) {
16379       {
16380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16381       };
16382     } catch (std::exception& e) {
16383       {
16384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16385       };
16386     } catch (Dali::DaliException e) {
16387       {
16388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16389       };
16390     } catch (...) {
16391       {
16392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16393       };
16394     }
16395   }
16396
16397   jresult = (void *)result;
16398
16399   //argout typemap for const std::string&
16400
16401   return jresult;
16402 }
16403
16404
16405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16406   void * jresult ;
16407   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16408   Dali::Property::Index arg2 ;
16409   Dali::Property::Type arg3 ;
16410   Dali::Property::Value *result = 0 ;
16411
16412   arg1 = (Dali::Property::Map *)jarg1;
16413   arg2 = (Dali::Property::Index)jarg2;
16414   arg3 = (Dali::Property::Type)jarg3;
16415   {
16416     try {
16417       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16418     } catch (std::out_of_range& e) {
16419       {
16420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16421       };
16422     } catch (std::exception& e) {
16423       {
16424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16425       };
16426     } catch (Dali::DaliException e) {
16427       {
16428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16429       };
16430     } catch (...) {
16431       {
16432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16433       };
16434     }
16435   }
16436
16437   jresult = (void *)result;
16438   return jresult;
16439 }
16440
16441
16442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16443   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16444
16445   arg1 = (Dali::Property::Map *)jarg1;
16446   {
16447     try {
16448       (arg1)->Clear();
16449     } catch (std::out_of_range& e) {
16450       {
16451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16452       };
16453     } catch (std::exception& e) {
16454       {
16455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16456       };
16457     } catch (Dali::DaliException e) {
16458       {
16459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16460       };
16461     } catch (...) {
16462       {
16463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16464       };
16465     }
16466   }
16467
16468 }
16469
16470
16471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16472   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16473   Dali::Property::Map *arg2 = 0 ;
16474
16475   arg1 = (Dali::Property::Map *)jarg1;
16476   arg2 = (Dali::Property::Map *)jarg2;
16477   if (!arg2) {
16478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16479     return ;
16480   }
16481   {
16482     try {
16483       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16484     } catch (std::out_of_range& e) {
16485       {
16486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16487       };
16488     } catch (std::exception& e) {
16489       {
16490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16491       };
16492     } catch (Dali::DaliException e) {
16493       {
16494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16495       };
16496     } catch (...) {
16497       {
16498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16499       };
16500     }
16501   }
16502
16503 }
16504
16505
16506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16507   void * jresult ;
16508   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16509   std::string *arg2 = 0 ;
16510   Dali::Property::Value *result = 0 ;
16511
16512   arg1 = (Dali::Property::Map *)jarg1;
16513   if (!jarg2) {
16514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16515     return 0;
16516   }
16517   std::string arg2_str(jarg2);
16518   arg2 = &arg2_str;
16519   {
16520     try {
16521       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16522     } catch (std::out_of_range& e) {
16523       {
16524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16525       };
16526     } catch (std::exception& e) {
16527       {
16528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16529       };
16530     } catch (Dali::DaliException e) {
16531       {
16532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16533       };
16534     } catch (...) {
16535       {
16536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16537       };
16538     }
16539   }
16540
16541   jresult = (void *)result;
16542
16543   //argout typemap for const std::string&
16544
16545   return jresult;
16546 }
16547
16548
16549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16550   void * jresult ;
16551   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16552   Dali::Property::Index arg2 ;
16553   Dali::Property::Value *result = 0 ;
16554
16555   arg1 = (Dali::Property::Map *)jarg1;
16556   arg2 = (Dali::Property::Index)jarg2;
16557   {
16558     try {
16559       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16560     } catch (std::out_of_range& e) {
16561       {
16562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16563       };
16564     } catch (std::exception& e) {
16565       {
16566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16567       };
16568     } catch (Dali::DaliException e) {
16569       {
16570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16571       };
16572     } catch (...) {
16573       {
16574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16575       };
16576     }
16577   }
16578
16579   jresult = (void *)result;
16580   return jresult;
16581 }
16582
16583
16584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16585   void * jresult ;
16586   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16587   Dali::Property::Map *arg2 = 0 ;
16588   Dali::Property::Map *result = 0 ;
16589
16590   arg1 = (Dali::Property::Map *)jarg1;
16591   arg2 = (Dali::Property::Map *)jarg2;
16592   if (!arg2) {
16593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16594     return 0;
16595   }
16596   {
16597     try {
16598       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16599     } catch (std::out_of_range& e) {
16600       {
16601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16602       };
16603     } catch (std::exception& e) {
16604       {
16605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16606       };
16607     } catch (Dali::DaliException e) {
16608       {
16609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16610       };
16611     } catch (...) {
16612       {
16613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16614       };
16615     }
16616   }
16617
16618   jresult = (void *)result;
16619   return jresult;
16620 }
16621
16622
16623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16624
16625   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16626
16627   if (!jarg2) {
16628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16629     return;
16630   }
16631   std::string arg2_str(jarg2);
16632   std::string* arg2 = &arg2_str;
16633
16634   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16635
16636   {
16637     try {
16638       arg1->operator[]((std::string const &)*arg2) = *arg3;
16639     } catch (std::out_of_range& e) {
16640       {
16641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16642       };
16643     } catch (std::exception& e) {
16644       {
16645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16646       };
16647     } catch (Dali::DaliException e) {
16648       {
16649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16650       };
16651     } catch (...) {
16652       {
16653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16654       };
16655     }
16656   }
16657 }
16658
16659
16660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16661
16662   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16663   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16664   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16665
16666   {
16667     try {
16668       arg1->operator[](arg2) = *arg3;
16669     } catch (std::out_of_range& e) {
16670       {
16671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16672       };
16673     } catch (std::exception& e) {
16674       {
16675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16676       };
16677     } catch (Dali::DaliException e) {
16678       {
16679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16680       };
16681     } catch (...) {
16682       {
16683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16684       };
16685     }
16686   }
16687 }
16688
16689
16690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16691   void * jresult ;
16692   Dali::Property::Value *result = 0 ;
16693
16694   {
16695     try {
16696       result = (Dali::Property::Value *)new Dali::Property::Value();
16697     } catch (std::out_of_range& e) {
16698       {
16699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16700       };
16701     } catch (std::exception& e) {
16702       {
16703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16704       };
16705     } catch (Dali::DaliException e) {
16706       {
16707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16708       };
16709     } catch (...) {
16710       {
16711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16712       };
16713     }
16714   }
16715
16716   jresult = (void *)result;
16717   return jresult;
16718 }
16719
16720
16721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16722   void * jresult ;
16723   bool arg1 ;
16724   Dali::Property::Value *result = 0 ;
16725
16726   arg1 = jarg1 ? true : false;
16727   {
16728     try {
16729       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16730     } catch (std::out_of_range& e) {
16731       {
16732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16733       };
16734     } catch (std::exception& e) {
16735       {
16736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16737       };
16738     } catch (Dali::DaliException e) {
16739       {
16740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16741       };
16742     } catch (...) {
16743       {
16744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16745       };
16746     }
16747   }
16748
16749   jresult = (void *)result;
16750   return jresult;
16751 }
16752
16753
16754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16755   void * jresult ;
16756   int arg1 ;
16757   Dali::Property::Value *result = 0 ;
16758
16759   arg1 = (int)jarg1;
16760   {
16761     try {
16762       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16763     } catch (std::out_of_range& e) {
16764       {
16765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16766       };
16767     } catch (std::exception& e) {
16768       {
16769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16770       };
16771     } catch (Dali::DaliException e) {
16772       {
16773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16774       };
16775     } catch (...) {
16776       {
16777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16778       };
16779     }
16780   }
16781
16782   jresult = (void *)result;
16783   return jresult;
16784 }
16785
16786
16787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16788   void * jresult ;
16789   float arg1 ;
16790   Dali::Property::Value *result = 0 ;
16791
16792   arg1 = (float)jarg1;
16793   {
16794     try {
16795       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16796     } catch (std::out_of_range& e) {
16797       {
16798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16799       };
16800     } catch (std::exception& e) {
16801       {
16802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16803       };
16804     } catch (Dali::DaliException e) {
16805       {
16806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16807       };
16808     } catch (...) {
16809       {
16810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16811       };
16812     }
16813   }
16814
16815   jresult = (void *)result;
16816   return jresult;
16817 }
16818
16819
16820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16821   void * jresult ;
16822   Dali::Vector2 *arg1 = 0 ;
16823   Dali::Property::Value *result = 0 ;
16824
16825   arg1 = (Dali::Vector2 *)jarg1;
16826   if (!arg1) {
16827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16828     return 0;
16829   }
16830   {
16831     try {
16832       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16833     } catch (std::out_of_range& e) {
16834       {
16835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16836       };
16837     } catch (std::exception& e) {
16838       {
16839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16840       };
16841     } catch (Dali::DaliException e) {
16842       {
16843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16844       };
16845     } catch (...) {
16846       {
16847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16848       };
16849     }
16850   }
16851
16852   jresult = (void *)result;
16853   return jresult;
16854 }
16855
16856
16857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16858   void * jresult ;
16859   Dali::Vector3 *arg1 = 0 ;
16860   Dali::Property::Value *result = 0 ;
16861
16862   arg1 = (Dali::Vector3 *)jarg1;
16863   if (!arg1) {
16864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16865     return 0;
16866   }
16867   {
16868     try {
16869       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16870     } catch (std::out_of_range& e) {
16871       {
16872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16873       };
16874     } catch (std::exception& e) {
16875       {
16876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16877       };
16878     } catch (Dali::DaliException e) {
16879       {
16880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16881       };
16882     } catch (...) {
16883       {
16884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16885       };
16886     }
16887   }
16888
16889   jresult = (void *)result;
16890   return jresult;
16891 }
16892
16893
16894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16895   void * jresult ;
16896   Dali::Vector4 *arg1 = 0 ;
16897   Dali::Property::Value *result = 0 ;
16898
16899   arg1 = (Dali::Vector4 *)jarg1;
16900   if (!arg1) {
16901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16902     return 0;
16903   }
16904   {
16905     try {
16906       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16907     } catch (std::out_of_range& e) {
16908       {
16909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16910       };
16911     } catch (std::exception& e) {
16912       {
16913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16914       };
16915     } catch (Dali::DaliException e) {
16916       {
16917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16918       };
16919     } catch (...) {
16920       {
16921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16922       };
16923     }
16924   }
16925
16926   jresult = (void *)result;
16927   return jresult;
16928 }
16929
16930
16931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16932   void * jresult ;
16933   Dali::Matrix3 *arg1 = 0 ;
16934   Dali::Property::Value *result = 0 ;
16935
16936   arg1 = (Dali::Matrix3 *)jarg1;
16937   if (!arg1) {
16938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16939     return 0;
16940   }
16941   {
16942     try {
16943       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16944     } catch (std::out_of_range& e) {
16945       {
16946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16947       };
16948     } catch (std::exception& e) {
16949       {
16950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16951       };
16952     } catch (Dali::DaliException e) {
16953       {
16954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16955       };
16956     } catch (...) {
16957       {
16958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16959       };
16960     }
16961   }
16962
16963   jresult = (void *)result;
16964   return jresult;
16965 }
16966
16967
16968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16969   void * jresult ;
16970   Dali::Matrix *arg1 = 0 ;
16971   Dali::Property::Value *result = 0 ;
16972
16973   arg1 = (Dali::Matrix *)jarg1;
16974   if (!arg1) {
16975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16976     return 0;
16977   }
16978   {
16979     try {
16980       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16981     } catch (std::out_of_range& e) {
16982       {
16983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16984       };
16985     } catch (std::exception& e) {
16986       {
16987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16988       };
16989     } catch (Dali::DaliException e) {
16990       {
16991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16992       };
16993     } catch (...) {
16994       {
16995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16996       };
16997     }
16998   }
16999
17000   jresult = (void *)result;
17001   return jresult;
17002 }
17003
17004
17005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
17006   void * jresult ;
17007   Dali::Rect< int > *arg1 = 0 ;
17008   Dali::Property::Value *result = 0 ;
17009
17010   arg1 = (Dali::Rect< int > *)jarg1;
17011   if (!arg1) {
17012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17013     return 0;
17014   }
17015   {
17016     try {
17017       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17018     } catch (std::out_of_range& e) {
17019       {
17020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17021       };
17022     } catch (std::exception& e) {
17023       {
17024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17025       };
17026     } catch (Dali::DaliException e) {
17027       {
17028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17029       };
17030     } catch (...) {
17031       {
17032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17033       };
17034     }
17035   }
17036
17037   jresult = (void *)result;
17038   return jresult;
17039 }
17040
17041
17042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17043   void * jresult ;
17044   Dali::AngleAxis *arg1 = 0 ;
17045   Dali::Property::Value *result = 0 ;
17046
17047   arg1 = (Dali::AngleAxis *)jarg1;
17048   if (!arg1) {
17049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17050     return 0;
17051   }
17052   {
17053     try {
17054       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17055     } catch (std::out_of_range& e) {
17056       {
17057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17058       };
17059     } catch (std::exception& e) {
17060       {
17061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17062       };
17063     } catch (Dali::DaliException e) {
17064       {
17065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17066       };
17067     } catch (...) {
17068       {
17069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17070       };
17071     }
17072   }
17073
17074   jresult = (void *)result;
17075   return jresult;
17076 }
17077
17078
17079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17080   void * jresult ;
17081   Dali::Quaternion *arg1 = 0 ;
17082   Dali::Property::Value *result = 0 ;
17083
17084   arg1 = (Dali::Quaternion *)jarg1;
17085   if (!arg1) {
17086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17087     return 0;
17088   }
17089   {
17090     try {
17091       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17092     } catch (std::out_of_range& e) {
17093       {
17094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17095       };
17096     } catch (std::exception& e) {
17097       {
17098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17099       };
17100     } catch (Dali::DaliException e) {
17101       {
17102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17103       };
17104     } catch (...) {
17105       {
17106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17107       };
17108     }
17109   }
17110
17111   jresult = (void *)result;
17112   return jresult;
17113 }
17114
17115
17116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17117   void * jresult ;
17118   std::string *arg1 = 0 ;
17119   Dali::Property::Value *result = 0 ;
17120
17121   if (!jarg1) {
17122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17123     return 0;
17124   }
17125   std::string arg1_str(jarg1);
17126   arg1 = &arg1_str;
17127   {
17128     try {
17129       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17130     } catch (std::out_of_range& e) {
17131       {
17132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17133       };
17134     } catch (std::exception& e) {
17135       {
17136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17137       };
17138     } catch (Dali::DaliException e) {
17139       {
17140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17141       };
17142     } catch (...) {
17143       {
17144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17145       };
17146     }
17147   }
17148
17149   jresult = (void *)result;
17150
17151   //argout typemap for const std::string&
17152
17153   return jresult;
17154 }
17155
17156
17157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17158   void * jresult ;
17159   Dali::Property::Array *arg1 = 0 ;
17160   Dali::Property::Value *result = 0 ;
17161
17162   arg1 = (Dali::Property::Array *)jarg1;
17163   if (!arg1) {
17164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17165     return 0;
17166   }
17167   {
17168     try {
17169       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17170     } catch (std::out_of_range& e) {
17171       {
17172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17173       };
17174     } catch (std::exception& e) {
17175       {
17176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17177       };
17178     } catch (Dali::DaliException e) {
17179       {
17180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17181       };
17182     } catch (...) {
17183       {
17184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17185       };
17186     }
17187   }
17188
17189   jresult = (void *)result;
17190   return jresult;
17191 }
17192
17193
17194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17195   void * jresult ;
17196   Dali::Property::Map *arg1 = 0 ;
17197   Dali::Property::Value *result = 0 ;
17198
17199   arg1 = (Dali::Property::Map *)jarg1;
17200   if (!arg1) {
17201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17202     return 0;
17203   }
17204   {
17205     try {
17206       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17207     } catch (std::out_of_range& e) {
17208       {
17209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17210       };
17211     } catch (std::exception& e) {
17212       {
17213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17214       };
17215     } catch (Dali::DaliException e) {
17216       {
17217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17218       };
17219     } catch (...) {
17220       {
17221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17222       };
17223     }
17224   }
17225
17226   jresult = (void *)result;
17227   return jresult;
17228 }
17229
17230
17231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17232   void * jresult ;
17233   Extents *arg1 = 0 ;
17234   Dali::Property::Value *result = 0 ;
17235
17236   arg1 = (Extents *)jarg1;
17237   if (!arg1) {
17238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17239     return 0;
17240   }
17241   {
17242     try {
17243       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17244     } catch (std::out_of_range& e) {
17245       {
17246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17247       };
17248     } catch (std::exception& e) {
17249       {
17250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17251       };
17252     } catch (...) {
17253       {
17254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17255       };
17256     }
17257   }
17258   jresult = (void *)result;
17259   return jresult;
17260 }
17261
17262
17263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17264   void * jresult ;
17265   Dali::Property::Type arg1 ;
17266   Dali::Property::Value *result = 0 ;
17267
17268   arg1 = (Dali::Property::Type)jarg1;
17269   {
17270     try {
17271       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17272     } catch (std::out_of_range& e) {
17273       {
17274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17275       };
17276     } catch (std::exception& e) {
17277       {
17278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17279       };
17280     } catch (Dali::DaliException e) {
17281       {
17282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17283       };
17284     } catch (...) {
17285       {
17286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17287       };
17288     }
17289   }
17290
17291   jresult = (void *)result;
17292   return jresult;
17293 }
17294
17295
17296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17297   void * jresult ;
17298   Dali::Property::Value *arg1 = 0 ;
17299   Dali::Property::Value *result = 0 ;
17300
17301   arg1 = (Dali::Property::Value *)jarg1;
17302   if (!arg1) {
17303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17304     return 0;
17305   }
17306   {
17307     try {
17308       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17309     } catch (std::out_of_range& e) {
17310       {
17311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17312       };
17313     } catch (std::exception& e) {
17314       {
17315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17316       };
17317     } catch (Dali::DaliException e) {
17318       {
17319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17320       };
17321     } catch (...) {
17322       {
17323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17324       };
17325     }
17326   }
17327
17328   jresult = (void *)result;
17329   return jresult;
17330 }
17331
17332
17333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17334   void * jresult ;
17335   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17336   Dali::Property::Value *arg2 = 0 ;
17337   Dali::Property::Value *result = 0 ;
17338
17339   arg1 = (Dali::Property::Value *)jarg1;
17340   arg2 = (Dali::Property::Value *)jarg2;
17341   if (!arg2) {
17342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17343     return 0;
17344   }
17345   {
17346     try {
17347       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17348     } catch (std::out_of_range& e) {
17349       {
17350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17351       };
17352     } catch (std::exception& e) {
17353       {
17354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17355       };
17356     } catch (Dali::DaliException e) {
17357       {
17358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17359       };
17360     } catch (...) {
17361       {
17362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17363       };
17364     }
17365   }
17366
17367   jresult = (void *)result;
17368   return jresult;
17369 }
17370
17371
17372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17373   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17374
17375   arg1 = (Dali::Property::Value *)jarg1;
17376   {
17377     try {
17378       delete arg1;
17379     } catch (std::out_of_range& e) {
17380       {
17381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17382       };
17383     } catch (std::exception& e) {
17384       {
17385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17386       };
17387     } catch (Dali::DaliException e) {
17388       {
17389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17390       };
17391     } catch (...) {
17392       {
17393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17394       };
17395     }
17396   }
17397
17398 }
17399
17400
17401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17402   int jresult ;
17403   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17404   Dali::Property::Type result;
17405
17406   arg1 = (Dali::Property::Value *)jarg1;
17407   {
17408     try {
17409       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17410     } catch (std::out_of_range& e) {
17411       {
17412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17413       };
17414     } catch (std::exception& e) {
17415       {
17416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17417       };
17418     } catch (Dali::DaliException e) {
17419       {
17420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17421       };
17422     } catch (...) {
17423       {
17424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17425       };
17426     }
17427   }
17428
17429   jresult = (int)result;
17430   return jresult;
17431 }
17432
17433
17434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17435   unsigned int jresult ;
17436   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17437   bool *arg2 = 0 ;
17438   bool result;
17439
17440   arg1 = (Dali::Property::Value *)jarg1;
17441   arg2 = (bool *)jarg2;
17442   {
17443     try {
17444       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17445     } catch (std::out_of_range& e) {
17446       {
17447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17448       };
17449     } catch (std::exception& e) {
17450       {
17451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17452       };
17453     } catch (Dali::DaliException e) {
17454       {
17455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17456       };
17457     } catch (...) {
17458       {
17459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17460       };
17461     }
17462   }
17463
17464   jresult = result;
17465   return jresult;
17466 }
17467
17468
17469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17470   unsigned int jresult ;
17471   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17472   float *arg2 = 0 ;
17473   bool result;
17474
17475   arg1 = (Dali::Property::Value *)jarg1;
17476   arg2 = (float *)jarg2;
17477   {
17478     try {
17479       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17480     } catch (std::out_of_range& e) {
17481       {
17482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17483       };
17484     } catch (std::exception& e) {
17485       {
17486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17487       };
17488     } catch (Dali::DaliException e) {
17489       {
17490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17491       };
17492     } catch (...) {
17493       {
17494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17495       };
17496     }
17497   }
17498
17499   jresult = result;
17500   return jresult;
17501 }
17502
17503
17504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17505   unsigned int jresult ;
17506   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17507   int *arg2 = 0 ;
17508   bool result;
17509
17510   arg1 = (Dali::Property::Value *)jarg1;
17511   arg2 = (int *)jarg2;
17512   {
17513     try {
17514       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17515     } catch (std::out_of_range& e) {
17516       {
17517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17518       };
17519     } catch (std::exception& e) {
17520       {
17521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17522       };
17523     } catch (Dali::DaliException e) {
17524       {
17525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17526       };
17527     } catch (...) {
17528       {
17529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17530       };
17531     }
17532   }
17533
17534   jresult = result;
17535   return jresult;
17536 }
17537
17538
17539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17540   unsigned int jresult ;
17541   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17542   Dali::Rect< int > *arg2 = 0 ;
17543   bool result;
17544
17545   arg1 = (Dali::Property::Value *)jarg1;
17546   arg2 = (Dali::Rect< int > *)jarg2;
17547   if (!arg2) {
17548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17549     return 0;
17550   }
17551   {
17552     try {
17553       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17554     } catch (std::out_of_range& e) {
17555       {
17556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17557       };
17558     } catch (std::exception& e) {
17559       {
17560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17561       };
17562     } catch (Dali::DaliException e) {
17563       {
17564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17565       };
17566     } catch (...) {
17567       {
17568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17569       };
17570     }
17571   }
17572
17573   jresult = result;
17574   return jresult;
17575 }
17576
17577
17578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17579   unsigned int jresult ;
17580   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17581   Dali::Vector2 *arg2 = 0 ;
17582   bool result;
17583
17584   arg1 = (Dali::Property::Value *)jarg1;
17585   arg2 = (Dali::Vector2 *)jarg2;
17586   if (!arg2) {
17587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17588     return 0;
17589   }
17590   {
17591     try {
17592       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17593     } catch (std::out_of_range& e) {
17594       {
17595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17596       };
17597     } catch (std::exception& e) {
17598       {
17599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17600       };
17601     } catch (Dali::DaliException e) {
17602       {
17603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17604       };
17605     } catch (...) {
17606       {
17607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17608       };
17609     }
17610   }
17611
17612   jresult = result;
17613   return jresult;
17614 }
17615
17616
17617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17618   unsigned int jresult ;
17619   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17620   Dali::Vector3 *arg2 = 0 ;
17621   bool result;
17622
17623   arg1 = (Dali::Property::Value *)jarg1;
17624   arg2 = (Dali::Vector3 *)jarg2;
17625   if (!arg2) {
17626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17627     return 0;
17628   }
17629   {
17630     try {
17631       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17632     } catch (std::out_of_range& e) {
17633       {
17634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17635       };
17636     } catch (std::exception& e) {
17637       {
17638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17639       };
17640     } catch (Dali::DaliException e) {
17641       {
17642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17643       };
17644     } catch (...) {
17645       {
17646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17647       };
17648     }
17649   }
17650
17651   jresult = result;
17652   return jresult;
17653 }
17654
17655
17656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17657   unsigned int jresult ;
17658   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17659   Dali::Vector4 *arg2 = 0 ;
17660   bool result;
17661
17662   arg1 = (Dali::Property::Value *)jarg1;
17663   arg2 = (Dali::Vector4 *)jarg2;
17664   if (!arg2) {
17665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17666     return 0;
17667   }
17668   {
17669     try {
17670       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17671     } catch (std::out_of_range& e) {
17672       {
17673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17674       };
17675     } catch (std::exception& e) {
17676       {
17677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17678       };
17679     } catch (Dali::DaliException e) {
17680       {
17681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17682       };
17683     } catch (...) {
17684       {
17685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17686       };
17687     }
17688   }
17689
17690   jresult = result;
17691   return jresult;
17692 }
17693
17694
17695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17696   unsigned int jresult ;
17697   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17698   Dali::Matrix3 *arg2 = 0 ;
17699   bool result;
17700
17701   arg1 = (Dali::Property::Value *)jarg1;
17702   arg2 = (Dali::Matrix3 *)jarg2;
17703   if (!arg2) {
17704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17705     return 0;
17706   }
17707   {
17708     try {
17709       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17710     } catch (std::out_of_range& e) {
17711       {
17712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17713       };
17714     } catch (std::exception& e) {
17715       {
17716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17717       };
17718     } catch (Dali::DaliException e) {
17719       {
17720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17721       };
17722     } catch (...) {
17723       {
17724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17725       };
17726     }
17727   }
17728
17729   jresult = result;
17730   return jresult;
17731 }
17732
17733
17734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17735   unsigned int jresult ;
17736   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17737   Dali::Matrix *arg2 = 0 ;
17738   bool result;
17739
17740   arg1 = (Dali::Property::Value *)jarg1;
17741   arg2 = (Dali::Matrix *)jarg2;
17742   if (!arg2) {
17743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17744     return 0;
17745   }
17746   {
17747     try {
17748       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17749     } catch (std::out_of_range& e) {
17750       {
17751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17752       };
17753     } catch (std::exception& e) {
17754       {
17755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17756       };
17757     } catch (Dali::DaliException e) {
17758       {
17759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17760       };
17761     } catch (...) {
17762       {
17763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17764       };
17765     }
17766   }
17767
17768   jresult = result;
17769   return jresult;
17770 }
17771
17772
17773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17774   unsigned int jresult ;
17775   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17776   Dali::AngleAxis *arg2 = 0 ;
17777   bool result;
17778
17779   arg1 = (Dali::Property::Value *)jarg1;
17780   arg2 = (Dali::AngleAxis *)jarg2;
17781   if (!arg2) {
17782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17783     return 0;
17784   }
17785   {
17786     try {
17787       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17788     } catch (std::out_of_range& e) {
17789       {
17790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17791       };
17792     } catch (std::exception& e) {
17793       {
17794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17795       };
17796     } catch (Dali::DaliException e) {
17797       {
17798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17799       };
17800     } catch (...) {
17801       {
17802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17803       };
17804     }
17805   }
17806
17807   jresult = result;
17808   return jresult;
17809 }
17810
17811
17812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17813   unsigned int jresult ;
17814   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17815   Dali::Quaternion *arg2 = 0 ;
17816   bool result;
17817
17818   arg1 = (Dali::Property::Value *)jarg1;
17819   arg2 = (Dali::Quaternion *)jarg2;
17820   if (!arg2) {
17821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17822     return 0;
17823   }
17824   {
17825     try {
17826       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17827     } catch (std::out_of_range& e) {
17828       {
17829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17830       };
17831     } catch (std::exception& e) {
17832       {
17833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17834       };
17835     } catch (Dali::DaliException e) {
17836       {
17837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17838       };
17839     } catch (...) {
17840       {
17841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17842       };
17843     }
17844   }
17845
17846   jresult = result;
17847   return jresult;
17848 }
17849
17850
17851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17852   unsigned int jresult ;
17853   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17854   std::string *arg2 = 0 ;
17855   bool result;
17856
17857   arg1 = (Dali::Property::Value *)jarg1;
17858
17859   //typemap in
17860   std::string temp;
17861   arg2 = &temp;
17862
17863   {
17864     try {
17865       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17866     } catch (std::out_of_range& e) {
17867       {
17868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17869       };
17870     } catch (std::exception& e) {
17871       {
17872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17873       };
17874     } catch (Dali::DaliException e) {
17875       {
17876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17877       };
17878     } catch (...) {
17879       {
17880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17881       };
17882     }
17883   }
17884
17885   jresult = result;
17886
17887   //Typemap argout in c++ file.
17888   //This will convert c++ string to c# string
17889   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17890
17891   return jresult;
17892 }
17893
17894
17895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17896   unsigned int jresult ;
17897   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17898   Dali::Property::Array *arg2 = 0 ;
17899   bool result;
17900
17901   arg1 = (Dali::Property::Value *)jarg1;
17902   arg2 = (Dali::Property::Array *)jarg2;
17903   if (!arg2) {
17904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17905     return 0;
17906   }
17907   {
17908     try {
17909       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17910     } catch (std::out_of_range& e) {
17911       {
17912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17913       };
17914     } catch (std::exception& e) {
17915       {
17916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17917       };
17918     } catch (Dali::DaliException e) {
17919       {
17920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17921       };
17922     } catch (...) {
17923       {
17924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17925       };
17926     }
17927   }
17928
17929   jresult = result;
17930   return jresult;
17931 }
17932
17933
17934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17935   unsigned int jresult ;
17936   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17937   Dali::Property::Map *arg2 = 0 ;
17938   bool result;
17939
17940   arg1 = (Dali::Property::Value *)jarg1;
17941   arg2 = (Dali::Property::Map *)jarg2;
17942   if (!arg2) {
17943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17944     return 0;
17945   }
17946   {
17947     try {
17948       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17949     } catch (std::out_of_range& e) {
17950       {
17951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17952       };
17953     } catch (std::exception& e) {
17954       {
17955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17956       };
17957     } catch (Dali::DaliException e) {
17958       {
17959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17960       };
17961     } catch (...) {
17962       {
17963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17964       };
17965     }
17966   }
17967
17968   jresult = result;
17969   return jresult;
17970 }
17971
17972
17973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17974   unsigned int jresult ;
17975   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17976   Extents *arg2 = 0 ;
17977   bool result;
17978
17979   arg1 = (Dali::Property::Value *)jarg1;
17980   arg2 = (Extents *)jarg2;
17981   if (!arg2) {
17982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17983     return 0;
17984   }
17985   {
17986     try {
17987       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17988     } catch (std::out_of_range& e) {
17989       {
17990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17991       };
17992     } catch (std::exception& e) {
17993       {
17994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17995       };
17996     } catch (...) {
17997       {
17998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17999       };
18000     }
18001   }
18002   jresult = result;
18003   return jresult;
18004 }
18005
18006
18007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
18008   void * jresult ;
18009   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18010   Dali::Property::Array *result = 0 ;
18011
18012   arg1 = (Dali::Property::Value *)jarg1;
18013   {
18014     try {
18015       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18016     } catch (std::out_of_range& e) {
18017       {
18018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18019       };
18020     } catch (std::exception& e) {
18021       {
18022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18023       };
18024     } catch (Dali::DaliException e) {
18025       {
18026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18027       };
18028     } catch (...) {
18029       {
18030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18031       };
18032     }
18033   }
18034
18035   jresult = (void *)result;
18036   return jresult;
18037 }
18038
18039
18040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18041   void * jresult ;
18042   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18043   Dali::Property::Map *result = 0 ;
18044
18045   arg1 = (Dali::Property::Value *)jarg1;
18046   {
18047     try {
18048       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18049     } catch (std::out_of_range& e) {
18050       {
18051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18052       };
18053     } catch (std::exception& e) {
18054       {
18055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18056       };
18057     } catch (Dali::DaliException e) {
18058       {
18059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18060       };
18061     } catch (...) {
18062       {
18063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18064       };
18065     }
18066   }
18067
18068   jresult = (void *)result;
18069   return jresult;
18070 }
18071
18072
18073 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18074   char * jresult ;
18075   Dali::Property::Type arg1 ;
18076   char *result = 0 ;
18077
18078   arg1 = (Dali::Property::Type)jarg1;
18079   {
18080     try {
18081       result = (char *)Dali::PropertyTypes::GetName(arg1);
18082     } catch (std::out_of_range& e) {
18083       {
18084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18085       };
18086     } catch (std::exception& e) {
18087       {
18088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18089       };
18090     } catch (Dali::DaliException e) {
18091       {
18092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18093       };
18094     } catch (...) {
18095       {
18096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18097       };
18098     }
18099   }
18100
18101   jresult = SWIG_csharp_string_callback((const char *)result);
18102   return jresult;
18103 }
18104
18105
18106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18107   unsigned int jresult ;
18108   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18109   std::string *arg2 = 0 ;
18110   Dali::Property::Map *arg3 = 0 ;
18111   bool result;
18112
18113   arg1 = (Dali::BaseObject *)jarg1;
18114   if (!jarg2) {
18115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18116     return 0;
18117   }
18118   std::string arg2_str(jarg2);
18119   arg2 = &arg2_str;
18120   arg3 = (Dali::Property::Map *)jarg3;
18121   if (!arg3) {
18122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18123     return 0;
18124   }
18125   {
18126     try {
18127       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18128     } catch (std::out_of_range& e) {
18129       {
18130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18131       };
18132     } catch (std::exception& e) {
18133       {
18134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18135       };
18136     } catch (Dali::DaliException e) {
18137       {
18138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18139       };
18140     } catch (...) {
18141       {
18142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18143       };
18144     }
18145   }
18146
18147   jresult = result;
18148
18149   //argout typemap for const std::string&
18150
18151   return jresult;
18152 }
18153
18154
18155 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18156   char * jresult ;
18157   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18158   std::string *result = 0 ;
18159
18160   arg1 = (Dali::BaseObject *)jarg1;
18161   {
18162     try {
18163       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18164     } catch (std::out_of_range& e) {
18165       {
18166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18167       };
18168     } catch (std::exception& e) {
18169       {
18170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18171       };
18172     } catch (Dali::DaliException e) {
18173       {
18174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18175       };
18176     } catch (...) {
18177       {
18178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18179       };
18180     }
18181   }
18182
18183   jresult = SWIG_csharp_string_callback(result->c_str());
18184   return jresult;
18185 }
18186
18187
18188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18189   unsigned int jresult ;
18190   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18191   Dali::TypeInfo *arg2 = 0 ;
18192   bool result;
18193
18194   arg1 = (Dali::BaseObject *)jarg1;
18195   arg2 = (Dali::TypeInfo *)jarg2;
18196   if (!arg2) {
18197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18198     return 0;
18199   }
18200   {
18201     try {
18202       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18203     } catch (std::out_of_range& e) {
18204       {
18205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18206       };
18207     } catch (std::exception& e) {
18208       {
18209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18210       };
18211     } catch (Dali::DaliException e) {
18212       {
18213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18214       };
18215     } catch (...) {
18216       {
18217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18218       };
18219     }
18220   }
18221
18222   jresult = result;
18223   return jresult;
18224 }
18225
18226
18227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18228   unsigned int jresult ;
18229   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18230   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18231   std::string *arg3 = 0 ;
18232   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18233   bool result;
18234
18235   arg1 = (Dali::BaseObject *)jarg1;
18236   arg2 = (ConnectionTrackerInterface *)jarg2;
18237   if (!jarg3) {
18238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18239     return 0;
18240   }
18241   std::string arg3_str(jarg3);
18242   arg3 = &arg3_str;
18243   arg4 = (FunctorDelegate *)jarg4;
18244   {
18245     try {
18246       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18247     } catch (std::out_of_range& e) {
18248       {
18249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18250       };
18251     } catch (std::exception& e) {
18252       {
18253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18254       };
18255     } catch (Dali::DaliException e) {
18256       {
18257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18258       };
18259     } catch (...) {
18260       {
18261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18262       };
18263     }
18264   }
18265
18266   jresult = result;
18267
18268   //argout typemap for const std::string&
18269
18270   return jresult;
18271 }
18272
18273
18274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18275   void * jresult ;
18276   Dali::BaseHandle *arg1 = 0 ;
18277   Dali::BaseObject *result = 0 ;
18278
18279   arg1 = (Dali::BaseHandle *)jarg1;
18280   if (!arg1) {
18281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18282     return 0;
18283   }
18284   {
18285     try {
18286       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18287     } catch (std::out_of_range& e) {
18288       {
18289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18290       };
18291     } catch (std::exception& e) {
18292       {
18293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18294       };
18295     } catch (Dali::DaliException e) {
18296       {
18297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18298       };
18299     } catch (...) {
18300       {
18301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18302       };
18303     }
18304   }
18305
18306   jresult = (void *)result;
18307   return jresult;
18308 }
18309
18310
18311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18312   void * jresult ;
18313   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18314   Dali::BaseHandle *result = 0 ;
18315
18316   arg1 = (Dali::BaseObject *)jarg1;
18317   {
18318     try {
18319       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18320     } catch (std::out_of_range& e) {
18321       {
18322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18323       };
18324     } catch (std::exception& e) {
18325       {
18326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18327       };
18328     } catch (Dali::DaliException e) {
18329       {
18330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18331       };
18332     } catch (...) {
18333       {
18334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18335       };
18336     }
18337   }
18338
18339   jresult = (void *)result;
18340   return jresult;
18341 }
18342
18343
18344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18345   void * jresult ;
18346   Dali::BaseHandle *result = 0 ;
18347
18348   {
18349     try {
18350       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18351     } catch (std::out_of_range& e) {
18352       {
18353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18354       };
18355     } catch (std::exception& e) {
18356       {
18357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18358       };
18359     } catch (Dali::DaliException e) {
18360       {
18361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18362       };
18363     } catch (...) {
18364       {
18365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18366       };
18367     }
18368   }
18369
18370   jresult = (void *)result;
18371   return jresult;
18372 }
18373
18374
18375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18376   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18377
18378   arg1 = (Dali::BaseHandle *)jarg1;
18379   {
18380     try {
18381       delete arg1;
18382     } catch (std::out_of_range& e) {
18383       {
18384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18385       };
18386     } catch (std::exception& e) {
18387       {
18388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18389       };
18390     } catch (Dali::DaliException e) {
18391       {
18392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18393       };
18394     } catch (...) {
18395       {
18396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18397       };
18398     }
18399   }
18400
18401 }
18402
18403
18404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18405   void * jresult ;
18406   Dali::BaseHandle *arg1 = 0 ;
18407   Dali::BaseHandle *result = 0 ;
18408
18409   arg1 = (Dali::BaseHandle *)jarg1;
18410   if (!arg1) {
18411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18412     return 0;
18413   }
18414   {
18415     try {
18416       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18417     } catch (std::out_of_range& e) {
18418       {
18419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18420       };
18421     } catch (std::exception& e) {
18422       {
18423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18424       };
18425     } catch (Dali::DaliException e) {
18426       {
18427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18428       };
18429     } catch (...) {
18430       {
18431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18432       };
18433     }
18434   }
18435
18436   jresult = (void *)result;
18437   return jresult;
18438 }
18439
18440
18441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18442   void * jresult ;
18443   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18444   Dali::BaseHandle *arg2 = 0 ;
18445   Dali::BaseHandle *result = 0 ;
18446
18447   arg1 = (Dali::BaseHandle *)jarg1;
18448   arg2 = (Dali::BaseHandle *)jarg2;
18449   if (!arg2) {
18450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18451     return 0;
18452   }
18453   {
18454     try {
18455       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18456     } catch (std::out_of_range& e) {
18457       {
18458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18459       };
18460     } catch (std::exception& e) {
18461       {
18462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18463       };
18464     } catch (Dali::DaliException e) {
18465       {
18466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18467       };
18468     } catch (...) {
18469       {
18470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18471       };
18472     }
18473   }
18474
18475   jresult = (void *)result;
18476   return jresult;
18477 }
18478
18479
18480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18481   unsigned int jresult ;
18482   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18483   std::string *arg2 = 0 ;
18484   Dali::Property::Map *arg3 = 0 ;
18485   bool result;
18486
18487   arg1 = (Dali::BaseHandle *)jarg1;
18488   if (!jarg2) {
18489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18490     return 0;
18491   }
18492   std::string arg2_str(jarg2);
18493   arg2 = &arg2_str;
18494   arg3 = (Dali::Property::Map *)jarg3;
18495   if (!arg3) {
18496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18497     return 0;
18498   }
18499   {
18500     try {
18501       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18502     } catch (std::out_of_range& e) {
18503       {
18504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18505       };
18506     } catch (std::exception& e) {
18507       {
18508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18509       };
18510     } catch (Dali::DaliException e) {
18511       {
18512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18513       };
18514     } catch (...) {
18515       {
18516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18517       };
18518     }
18519   }
18520
18521   jresult = result;
18522
18523   //argout typemap for const std::string&
18524
18525   return jresult;
18526 }
18527
18528
18529 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18530   char * jresult ;
18531   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18532   std::string *result = 0 ;
18533
18534   arg1 = (Dali::BaseHandle *)jarg1;
18535   {
18536     try {
18537       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18538     } catch (std::out_of_range& e) {
18539       {
18540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18541       };
18542     } catch (std::exception& e) {
18543       {
18544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18545       };
18546     } catch (Dali::DaliException e) {
18547       {
18548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18549       };
18550     } catch (...) {
18551       {
18552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18553       };
18554     }
18555   }
18556
18557   jresult = SWIG_csharp_string_callback(result->c_str());
18558   return jresult;
18559 }
18560
18561
18562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18563   unsigned int jresult ;
18564   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18565   Dali::TypeInfo *arg2 = 0 ;
18566   bool result;
18567
18568   arg1 = (Dali::BaseHandle *)jarg1;
18569   arg2 = (Dali::TypeInfo *)jarg2;
18570   if (!arg2) {
18571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18572     return 0;
18573   }
18574   {
18575     try {
18576       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18577     } catch (std::out_of_range& e) {
18578       {
18579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18580       };
18581     } catch (std::exception& e) {
18582       {
18583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18584       };
18585     } catch (Dali::DaliException e) {
18586       {
18587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18588       };
18589     } catch (...) {
18590       {
18591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18592       };
18593     }
18594   }
18595
18596   jresult = result;
18597   return jresult;
18598 }
18599
18600
18601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18602   void * jresult ;
18603   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18604   Dali::BaseObject *result = 0 ;
18605
18606   arg1 = (Dali::BaseHandle *)jarg1;
18607   {
18608     try {
18609       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18610     } catch (std::out_of_range& e) {
18611       {
18612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18613       };
18614     } catch (std::exception& e) {
18615       {
18616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18617       };
18618     } catch (Dali::DaliException e) {
18619       {
18620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18621       };
18622     } catch (...) {
18623       {
18624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18625       };
18626     }
18627   }
18628
18629   jresult = (void *)result;
18630   return jresult;
18631 }
18632
18633
18634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18635   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18636
18637   arg1 = (Dali::BaseHandle *)jarg1;
18638   {
18639     try {
18640       (arg1)->Reset();
18641     } catch (std::out_of_range& e) {
18642       {
18643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18644       };
18645     } catch (std::exception& e) {
18646       {
18647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18648       };
18649     } catch (Dali::DaliException e) {
18650       {
18651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18652       };
18653     } catch (...) {
18654       {
18655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18656       };
18657     }
18658   }
18659
18660 }
18661
18662
18663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18664   unsigned int jresult ;
18665   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18666   Dali::BaseHandle *arg2 = 0 ;
18667   bool result;
18668
18669   arg1 = (Dali::BaseHandle *)jarg1;
18670   arg2 = (Dali::BaseHandle *)jarg2;
18671   if (!arg2) {
18672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18673     return 0;
18674   }
18675   {
18676     try {
18677       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18678     } catch (std::out_of_range& e) {
18679       {
18680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18681       };
18682     } catch (std::exception& e) {
18683       {
18684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18685       };
18686     } catch (Dali::DaliException e) {
18687       {
18688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18689       };
18690     } catch (...) {
18691       {
18692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18693       };
18694     }
18695   }
18696
18697   jresult = result;
18698   return jresult;
18699 }
18700
18701
18702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18703   unsigned int jresult ;
18704   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18705   Dali::BaseHandle *arg2 = 0 ;
18706   bool result;
18707
18708   arg1 = (Dali::BaseHandle *)jarg1;
18709   arg2 = (Dali::BaseHandle *)jarg2;
18710   if (!arg2) {
18711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18712     return 0;
18713   }
18714   {
18715     try {
18716       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18717     } catch (std::out_of_range& e) {
18718       {
18719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18720       };
18721     } catch (std::exception& e) {
18722       {
18723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18724       };
18725     } catch (Dali::DaliException e) {
18726       {
18727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18728       };
18729     } catch (...) {
18730       {
18731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18732       };
18733     }
18734   }
18735
18736   jresult = result;
18737   return jresult;
18738 }
18739
18740
18741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18742   void * jresult ;
18743   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18744   Dali::RefObject *result = 0 ;
18745
18746   arg1 = (Dali::BaseHandle *)jarg1;
18747   {
18748     try {
18749       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18750     } catch (std::out_of_range& e) {
18751       {
18752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18753       };
18754     } catch (std::exception& e) {
18755       {
18756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18757       };
18758     } catch (Dali::DaliException e) {
18759       {
18760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18761       };
18762     } catch (...) {
18763       {
18764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18765       };
18766     }
18767   }
18768
18769   jresult = (void *)result;
18770   return jresult;
18771 }
18772
18773
18774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18775   unsigned int jresult ;
18776   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18777   bool result;
18778
18779   arg1 = (Dali::BaseHandle *)jarg1;
18780   {
18781     try {
18782       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18783     } catch (std::out_of_range& e) {
18784       {
18785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18786       };
18787     } catch (std::exception& e) {
18788       {
18789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18790       };
18791     } catch (Dali::DaliException e) {
18792       {
18793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18794       };
18795     } catch (...) {
18796       {
18797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18798       };
18799     }
18800   }
18801
18802   jresult = result;
18803   return jresult;
18804 }
18805
18806
18807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18808   unsigned int jresult ;
18809   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18810   Dali::BaseHandle *arg2 = 0 ;
18811   bool result;
18812
18813   arg1 = (Dali::BaseHandle *)jarg1;
18814   arg2 = (Dali::BaseHandle *)jarg2;
18815   if (!arg2) {
18816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18817     return 0;
18818   }
18819   {
18820     try {
18821       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18822     } catch (std::out_of_range& e) {
18823       {
18824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18825       };
18826     } catch (std::exception& e) {
18827       {
18828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18829       };
18830     } catch (Dali::DaliException e) {
18831       {
18832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18833       };
18834     } catch (...) {
18835       {
18836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18837       };
18838     }
18839   }
18840
18841   jresult = result;
18842   return jresult;
18843 }
18844
18845
18846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18847   unsigned int jresult ;
18848   Dali::BaseHandle *arg1 = 0 ;
18849   Dali::BaseHandle *arg2 = 0 ;
18850   bool result;
18851
18852   arg1 = (Dali::BaseHandle *)jarg1;
18853   if (!arg1) {
18854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18855     return 0;
18856   }
18857   arg2 = (Dali::BaseHandle *)jarg2;
18858   if (!arg2) {
18859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18860     return 0;
18861   }
18862   {
18863     try {
18864       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18865     } catch (std::out_of_range& e) {
18866       {
18867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18868       };
18869     } catch (std::exception& e) {
18870       {
18871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18872       };
18873     } catch (Dali::DaliException e) {
18874       {
18875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18876       };
18877     } catch (...) {
18878       {
18879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18880       };
18881     }
18882   }
18883
18884   jresult = result;
18885   return jresult;
18886 }
18887
18888
18889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18890   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18891
18892   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18893   {
18894     try {
18895       delete arg1;
18896     } catch (std::out_of_range& e) {
18897       {
18898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18899       };
18900     } catch (std::exception& e) {
18901       {
18902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18903       };
18904     } catch (Dali::DaliException e) {
18905       {
18906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18907       };
18908     } catch (...) {
18909       {
18910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18911       };
18912     }
18913   }
18914
18915 }
18916
18917
18918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18919   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18920   SlotObserver *arg2 = (SlotObserver *) 0 ;
18921   CallbackBase *arg3 = (CallbackBase *) 0 ;
18922
18923   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18924   arg2 = (SlotObserver *)jarg2;
18925   arg3 = (CallbackBase *)jarg3;
18926   {
18927     try {
18928       (arg1)->SignalConnected(arg2,arg3);
18929     } catch (std::out_of_range& e) {
18930       {
18931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18932       };
18933     } catch (std::exception& e) {
18934       {
18935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18936       };
18937     } catch (Dali::DaliException e) {
18938       {
18939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18940       };
18941     } catch (...) {
18942       {
18943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18944       };
18945     }
18946   }
18947
18948 }
18949
18950
18951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18952   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18953
18954   arg1 = (Dali::SignalObserver *)jarg1;
18955   {
18956     try {
18957       delete arg1;
18958     } catch (std::out_of_range& e) {
18959       {
18960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18961       };
18962     } catch (std::exception& e) {
18963       {
18964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18965       };
18966     } catch (Dali::DaliException e) {
18967       {
18968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18969       };
18970     } catch (...) {
18971       {
18972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18973       };
18974     }
18975   }
18976
18977 }
18978
18979
18980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18981   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18982   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18983   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18984
18985   arg1 = (Dali::SignalObserver *)jarg1;
18986   arg2 = (Dali::SlotObserver *)jarg2;
18987   arg3 = (Dali::CallbackBase *)jarg3;
18988   {
18989     try {
18990       (arg1)->SignalDisconnected(arg2,arg3);
18991     } catch (std::out_of_range& e) {
18992       {
18993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18994       };
18995     } catch (std::exception& e) {
18996       {
18997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18998       };
18999     } catch (Dali::DaliException e) {
19000       {
19001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19002       };
19003     } catch (...) {
19004       {
19005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19006       };
19007     }
19008   }
19009
19010 }
19011
19012
19013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19014   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19015
19016   arg1 = (Dali::SlotObserver *)jarg1;
19017   {
19018     try {
19019       delete arg1;
19020     } catch (std::out_of_range& e) {
19021       {
19022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19023       };
19024     } catch (std::exception& e) {
19025       {
19026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19027       };
19028     } catch (Dali::DaliException e) {
19029       {
19030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19031       };
19032     } catch (...) {
19033       {
19034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19035       };
19036     }
19037   }
19038
19039 }
19040
19041
19042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19043   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19044   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19045
19046   arg1 = (Dali::SlotObserver *)jarg1;
19047   arg2 = (Dali::CallbackBase *)jarg2;
19048   {
19049     try {
19050       (arg1)->SlotDisconnected(arg2);
19051     } catch (std::out_of_range& e) {
19052       {
19053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19054       };
19055     } catch (std::exception& e) {
19056       {
19057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19058       };
19059     } catch (Dali::DaliException e) {
19060       {
19061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19062       };
19063     } catch (...) {
19064       {
19065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19066       };
19067     }
19068   }
19069
19070 }
19071
19072
19073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19074   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19075
19076   arg1 = (Dali::ConnectionTracker *)jarg1;
19077   {
19078     try {
19079       delete arg1;
19080     } catch (std::out_of_range& e) {
19081       {
19082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19083       };
19084     } catch (std::exception& e) {
19085       {
19086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19087       };
19088     } catch (Dali::DaliException e) {
19089       {
19090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19091       };
19092     } catch (...) {
19093       {
19094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19095       };
19096     }
19097   }
19098
19099 }
19100
19101
19102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19103   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19104
19105   arg1 = (Dali::ConnectionTracker *)jarg1;
19106   {
19107     try {
19108       (arg1)->DisconnectAll();
19109     } catch (std::out_of_range& e) {
19110       {
19111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19112       };
19113     } catch (std::exception& e) {
19114       {
19115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19116       };
19117     } catch (Dali::DaliException e) {
19118       {
19119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19120       };
19121     } catch (...) {
19122       {
19123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19124       };
19125     }
19126   }
19127
19128 }
19129
19130
19131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19132   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19133   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19134   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19135
19136   arg1 = (Dali::ConnectionTracker *)jarg1;
19137   arg2 = (Dali::SlotObserver *)jarg2;
19138   arg3 = (Dali::CallbackBase *)jarg3;
19139   {
19140     try {
19141       (arg1)->SignalConnected(arg2,arg3);
19142     } catch (std::out_of_range& e) {
19143       {
19144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19145       };
19146     } catch (std::exception& e) {
19147       {
19148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19149       };
19150     } catch (Dali::DaliException e) {
19151       {
19152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19153       };
19154     } catch (...) {
19155       {
19156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19157       };
19158     }
19159   }
19160
19161 }
19162
19163
19164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19165   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19166   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19167   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19168
19169   arg1 = (Dali::ConnectionTracker *)jarg1;
19170   arg2 = (Dali::SlotObserver *)jarg2;
19171   arg3 = (Dali::CallbackBase *)jarg3;
19172   {
19173     try {
19174       (arg1)->SignalDisconnected(arg2,arg3);
19175     } catch (std::out_of_range& e) {
19176       {
19177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19178       };
19179     } catch (std::exception& e) {
19180       {
19181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19182       };
19183     } catch (Dali::DaliException e) {
19184       {
19185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19186       };
19187     } catch (...) {
19188       {
19189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19190       };
19191     }
19192   }
19193
19194 }
19195
19196
19197 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19198   unsigned long jresult ;
19199   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19200   std::size_t result;
19201
19202   arg1 = (Dali::ConnectionTracker *)jarg1;
19203   {
19204     try {
19205       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19206     } catch (std::out_of_range& e) {
19207       {
19208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19209       };
19210     } catch (std::exception& e) {
19211       {
19212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19213       };
19214     } catch (Dali::DaliException e) {
19215       {
19216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19217       };
19218     } catch (...) {
19219       {
19220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19221       };
19222     }
19223   }
19224
19225   jresult = (unsigned long)result;
19226   return jresult;
19227 }
19228
19229
19230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19231   void * jresult ;
19232   Dali::ObjectRegistry *result = 0 ;
19233
19234   {
19235     try {
19236       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19237     } catch (std::out_of_range& e) {
19238       {
19239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19240       };
19241     } catch (std::exception& e) {
19242       {
19243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19244       };
19245     } catch (Dali::DaliException e) {
19246       {
19247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19248       };
19249     } catch (...) {
19250       {
19251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19252       };
19253     }
19254   }
19255
19256   jresult = (void *)result;
19257   return jresult;
19258 }
19259
19260
19261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19262   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19263
19264   arg1 = (Dali::ObjectRegistry *)jarg1;
19265   {
19266     try {
19267       delete arg1;
19268     } catch (std::out_of_range& e) {
19269       {
19270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19271       };
19272     } catch (std::exception& e) {
19273       {
19274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19275       };
19276     } catch (Dali::DaliException e) {
19277       {
19278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19279       };
19280     } catch (...) {
19281       {
19282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19283       };
19284     }
19285   }
19286
19287 }
19288
19289
19290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19291   void * jresult ;
19292   Dali::ObjectRegistry *arg1 = 0 ;
19293   Dali::ObjectRegistry *result = 0 ;
19294
19295   arg1 = (Dali::ObjectRegistry *)jarg1;
19296   if (!arg1) {
19297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19298     return 0;
19299   }
19300   {
19301     try {
19302       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19303     } catch (std::out_of_range& e) {
19304       {
19305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19306       };
19307     } catch (std::exception& e) {
19308       {
19309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19310       };
19311     } catch (Dali::DaliException e) {
19312       {
19313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19314       };
19315     } catch (...) {
19316       {
19317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19318       };
19319     }
19320   }
19321
19322   jresult = (void *)result;
19323   return jresult;
19324 }
19325
19326
19327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19328   void * jresult ;
19329   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19330   Dali::ObjectRegistry *arg2 = 0 ;
19331   Dali::ObjectRegistry *result = 0 ;
19332
19333   arg1 = (Dali::ObjectRegistry *)jarg1;
19334   arg2 = (Dali::ObjectRegistry *)jarg2;
19335   if (!arg2) {
19336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19337     return 0;
19338   }
19339   {
19340     try {
19341       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19342     } catch (std::out_of_range& e) {
19343       {
19344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19345       };
19346     } catch (std::exception& e) {
19347       {
19348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19349       };
19350     } catch (Dali::DaliException e) {
19351       {
19352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19353       };
19354     } catch (...) {
19355       {
19356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19357       };
19358     }
19359   }
19360
19361   jresult = (void *)result;
19362   return jresult;
19363 }
19364
19365
19366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19367   void * jresult ;
19368   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19369   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19370
19371   arg1 = (Dali::ObjectRegistry *)jarg1;
19372   {
19373     try {
19374       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19375     } catch (std::out_of_range& e) {
19376       {
19377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19378       };
19379     } catch (std::exception& e) {
19380       {
19381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19382       };
19383     } catch (Dali::DaliException e) {
19384       {
19385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19386       };
19387     } catch (...) {
19388       {
19389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19390       };
19391     }
19392   }
19393
19394   jresult = (void *)result;
19395   return jresult;
19396 }
19397
19398
19399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19400   void * jresult ;
19401   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19402   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19403
19404   arg1 = (Dali::ObjectRegistry *)jarg1;
19405   {
19406     try {
19407       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19408     } catch (std::out_of_range& e) {
19409       {
19410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19411       };
19412     } catch (std::exception& e) {
19413       {
19414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19415       };
19416     } catch (Dali::DaliException e) {
19417       {
19418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19419       };
19420     } catch (...) {
19421       {
19422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19423       };
19424     }
19425   }
19426
19427   jresult = (void *)result;
19428   return jresult;
19429 }
19430
19431
19432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19433   void * jresult ;
19434   Dali::PropertyCondition *result = 0 ;
19435
19436   {
19437     try {
19438       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19439     } catch (std::out_of_range& e) {
19440       {
19441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19442       };
19443     } catch (std::exception& e) {
19444       {
19445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19446       };
19447     } catch (Dali::DaliException e) {
19448       {
19449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19450       };
19451     } catch (...) {
19452       {
19453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19454       };
19455     }
19456   }
19457
19458   jresult = (void *)result;
19459   return jresult;
19460 }
19461
19462
19463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19464   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19465
19466   arg1 = (Dali::PropertyCondition *)jarg1;
19467   {
19468     try {
19469       delete arg1;
19470     } catch (std::out_of_range& e) {
19471       {
19472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19473       };
19474     } catch (std::exception& e) {
19475       {
19476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19477       };
19478     } catch (Dali::DaliException e) {
19479       {
19480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19481       };
19482     } catch (...) {
19483       {
19484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19485       };
19486     }
19487   }
19488
19489 }
19490
19491
19492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19493   void * jresult ;
19494   Dali::PropertyCondition *arg1 = 0 ;
19495   Dali::PropertyCondition *result = 0 ;
19496
19497   arg1 = (Dali::PropertyCondition *)jarg1;
19498   if (!arg1) {
19499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19500     return 0;
19501   }
19502   {
19503     try {
19504       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19505     } catch (std::out_of_range& e) {
19506       {
19507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19508       };
19509     } catch (std::exception& e) {
19510       {
19511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19512       };
19513     } catch (Dali::DaliException e) {
19514       {
19515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19516       };
19517     } catch (...) {
19518       {
19519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19520       };
19521     }
19522   }
19523
19524   jresult = (void *)result;
19525   return jresult;
19526 }
19527
19528
19529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19530   void * jresult ;
19531   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19532   Dali::PropertyCondition *arg2 = 0 ;
19533   Dali::PropertyCondition *result = 0 ;
19534
19535   arg1 = (Dali::PropertyCondition *)jarg1;
19536   arg2 = (Dali::PropertyCondition *)jarg2;
19537   if (!arg2) {
19538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19539     return 0;
19540   }
19541   {
19542     try {
19543       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19544     } catch (std::out_of_range& e) {
19545       {
19546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19547       };
19548     } catch (std::exception& e) {
19549       {
19550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19551       };
19552     } catch (Dali::DaliException e) {
19553       {
19554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19555       };
19556     } catch (...) {
19557       {
19558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19559       };
19560     }
19561   }
19562
19563   jresult = (void *)result;
19564   return jresult;
19565 }
19566
19567
19568 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19569   unsigned long jresult ;
19570   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19571   std::size_t result;
19572
19573   arg1 = (Dali::PropertyCondition *)jarg1;
19574   {
19575     try {
19576       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19577     } catch (std::out_of_range& e) {
19578       {
19579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19580       };
19581     } catch (std::exception& e) {
19582       {
19583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19584       };
19585     } catch (...) {
19586       {
19587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19588       };
19589     }
19590   }
19591   jresult = (unsigned long)result;
19592   return jresult;
19593 }
19594
19595
19596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19597   float jresult ;
19598   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19599   std::size_t arg2 ;
19600   float result;
19601
19602   arg1 = (Dali::PropertyCondition *)jarg1;
19603   arg2 = (std::size_t)jarg2;
19604   {
19605     try {
19606       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19607     } catch (std::out_of_range& e) {
19608       {
19609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19610       };
19611     } catch (std::exception& e) {
19612       {
19613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19614       };
19615     } catch (...) {
19616       {
19617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19618       };
19619     }
19620   }
19621   jresult = result;
19622   return jresult;
19623 }
19624
19625
19626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19627   void * jresult ;
19628   float arg1 ;
19629   Dali::PropertyCondition result;
19630
19631   arg1 = (float)jarg1;
19632   {
19633     try {
19634       result = Dali::LessThanCondition(arg1);
19635     } catch (std::out_of_range& e) {
19636       {
19637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19638       };
19639     } catch (std::exception& e) {
19640       {
19641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19642       };
19643     } catch (Dali::DaliException e) {
19644       {
19645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19646       };
19647     } catch (...) {
19648       {
19649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19650       };
19651     }
19652   }
19653
19654   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19655   return jresult;
19656 }
19657
19658
19659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19660   void * jresult ;
19661   float arg1 ;
19662   Dali::PropertyCondition result;
19663
19664   arg1 = (float)jarg1;
19665   {
19666     try {
19667       result = Dali::GreaterThanCondition(arg1);
19668     } catch (std::out_of_range& e) {
19669       {
19670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19671       };
19672     } catch (std::exception& e) {
19673       {
19674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19675       };
19676     } catch (Dali::DaliException e) {
19677       {
19678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19679       };
19680     } catch (...) {
19681       {
19682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19683       };
19684     }
19685   }
19686
19687   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19688   return jresult;
19689 }
19690
19691
19692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19693   void * jresult ;
19694   float arg1 ;
19695   float arg2 ;
19696   Dali::PropertyCondition result;
19697
19698   arg1 = (float)jarg1;
19699   arg2 = (float)jarg2;
19700   {
19701     try {
19702       result = Dali::InsideCondition(arg1,arg2);
19703     } catch (std::out_of_range& e) {
19704       {
19705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19706       };
19707     } catch (std::exception& e) {
19708       {
19709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19710       };
19711     } catch (Dali::DaliException e) {
19712       {
19713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19714       };
19715     } catch (...) {
19716       {
19717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19718       };
19719     }
19720   }
19721
19722   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19723   return jresult;
19724 }
19725
19726
19727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19728   void * jresult ;
19729   float arg1 ;
19730   float arg2 ;
19731   Dali::PropertyCondition result;
19732
19733   arg1 = (float)jarg1;
19734   arg2 = (float)jarg2;
19735   {
19736     try {
19737       result = Dali::OutsideCondition(arg1,arg2);
19738     } catch (std::out_of_range& e) {
19739       {
19740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19741       };
19742     } catch (std::exception& e) {
19743       {
19744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19745       };
19746     } catch (Dali::DaliException e) {
19747       {
19748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19749       };
19750     } catch (...) {
19751       {
19752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19753       };
19754     }
19755   }
19756
19757   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19758   return jresult;
19759 }
19760
19761
19762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19763   void * jresult ;
19764   float arg1 ;
19765   float arg2 ;
19766   Dali::PropertyCondition result;
19767
19768   arg1 = (float)jarg1;
19769   arg2 = (float)jarg2;
19770   {
19771     try {
19772       result = Dali::StepCondition(arg1,arg2);
19773     } catch (std::out_of_range& e) {
19774       {
19775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19776       };
19777     } catch (std::exception& e) {
19778       {
19779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19780       };
19781     } catch (Dali::DaliException e) {
19782       {
19783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19784       };
19785     } catch (...) {
19786       {
19787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19788       };
19789     }
19790   }
19791
19792   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19793   return jresult;
19794 }
19795
19796
19797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19798   void * jresult ;
19799   float arg1 ;
19800   Dali::PropertyCondition result;
19801
19802   arg1 = (float)jarg1;
19803   {
19804     try {
19805       result = Dali::StepCondition(arg1);
19806     } catch (std::out_of_range& e) {
19807       {
19808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19809       };
19810     } catch (std::exception& e) {
19811       {
19812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19813       };
19814     } catch (Dali::DaliException e) {
19815       {
19816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19817       };
19818     } catch (...) {
19819       {
19820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19821       };
19822     }
19823   }
19824
19825   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19826   return jresult;
19827 }
19828
19829
19830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19831   void * jresult ;
19832   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19833   Dali::PropertyCondition result;
19834
19835   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19836   if (!arg1) {
19837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19838     return 0;
19839   }
19840   {
19841     try {
19842       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19843     } catch (std::out_of_range& e) {
19844       {
19845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19846       };
19847     } catch (std::exception& e) {
19848       {
19849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19850       };
19851     } catch (Dali::DaliException e) {
19852       {
19853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19854       };
19855     } catch (...) {
19856       {
19857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19858       };
19859     }
19860   }
19861
19862   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19863   return jresult;
19864 }
19865
19866
19867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19868   void * jresult ;
19869   Dali::PropertyNotification *result = 0 ;
19870
19871   {
19872     try {
19873       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19874     } catch (std::out_of_range& e) {
19875       {
19876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19877       };
19878     } catch (std::exception& e) {
19879       {
19880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19881       };
19882     } catch (Dali::DaliException e) {
19883       {
19884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19885       };
19886     } catch (...) {
19887       {
19888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19889       };
19890     }
19891   }
19892
19893   jresult = (void *)result;
19894   return jresult;
19895 }
19896
19897
19898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19899   void * jresult ;
19900   Dali::BaseHandle arg1 ;
19901   Dali::BaseHandle *argp1 ;
19902   Dali::PropertyNotification result;
19903
19904   argp1 = (Dali::BaseHandle *)jarg1;
19905   if (!argp1) {
19906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19907     return 0;
19908   }
19909   arg1 = *argp1;
19910   {
19911     try {
19912       result = Dali::PropertyNotification::DownCast(arg1);
19913     } catch (std::out_of_range& e) {
19914       {
19915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19916       };
19917     } catch (std::exception& e) {
19918       {
19919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19920       };
19921     } catch (Dali::DaliException e) {
19922       {
19923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19924       };
19925     } catch (...) {
19926       {
19927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19928       };
19929     }
19930   }
19931
19932   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19933   return jresult;
19934 }
19935
19936
19937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19938   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19939
19940   arg1 = (Dali::PropertyNotification *)jarg1;
19941   {
19942     try {
19943       delete arg1;
19944     } catch (std::out_of_range& e) {
19945       {
19946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19947       };
19948     } catch (std::exception& e) {
19949       {
19950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19951       };
19952     } catch (Dali::DaliException e) {
19953       {
19954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19955       };
19956     } catch (...) {
19957       {
19958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19959       };
19960     }
19961   }
19962
19963 }
19964
19965
19966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19967   void * jresult ;
19968   Dali::PropertyNotification *arg1 = 0 ;
19969   Dali::PropertyNotification *result = 0 ;
19970
19971   arg1 = (Dali::PropertyNotification *)jarg1;
19972   if (!arg1) {
19973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19974     return 0;
19975   }
19976   {
19977     try {
19978       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19979     } catch (std::out_of_range& e) {
19980       {
19981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19982       };
19983     } catch (std::exception& e) {
19984       {
19985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19986       };
19987     } catch (Dali::DaliException e) {
19988       {
19989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19990       };
19991     } catch (...) {
19992       {
19993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19994       };
19995     }
19996   }
19997
19998   jresult = (void *)result;
19999   return jresult;
20000 }
20001
20002
20003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
20004   void * jresult ;
20005   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20006   Dali::PropertyNotification *arg2 = 0 ;
20007   Dali::PropertyNotification *result = 0 ;
20008
20009   arg1 = (Dali::PropertyNotification *)jarg1;
20010   arg2 = (Dali::PropertyNotification *)jarg2;
20011   if (!arg2) {
20012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20013     return 0;
20014   }
20015   {
20016     try {
20017       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20018     } catch (std::out_of_range& e) {
20019       {
20020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20021       };
20022     } catch (std::exception& e) {
20023       {
20024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20025       };
20026     } catch (Dali::DaliException e) {
20027       {
20028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20029       };
20030     } catch (...) {
20031       {
20032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20033       };
20034     }
20035   }
20036
20037   jresult = (void *)result;
20038   return jresult;
20039 }
20040
20041
20042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20043   void * jresult ;
20044   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20045   Dali::PropertyCondition result;
20046
20047   arg1 = (Dali::PropertyNotification *)jarg1;
20048   {
20049     try {
20050       result = (arg1)->GetCondition();
20051     } catch (std::out_of_range& e) {
20052       {
20053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20054       };
20055     } catch (std::exception& e) {
20056       {
20057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20058       };
20059     } catch (Dali::DaliException e) {
20060       {
20061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20062       };
20063     } catch (...) {
20064       {
20065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20066       };
20067     }
20068   }
20069
20070   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20071   return jresult;
20072 }
20073
20074
20075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20076   void * jresult ;
20077   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20078   Dali::Handle result;
20079
20080   arg1 = (Dali::PropertyNotification *)jarg1;
20081   {
20082     try {
20083       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20084     } catch (std::out_of_range& e) {
20085       {
20086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20087       };
20088     } catch (std::exception& e) {
20089       {
20090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20091       };
20092     } catch (Dali::DaliException e) {
20093       {
20094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20095       };
20096     } catch (...) {
20097       {
20098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20099       };
20100     }
20101   }
20102
20103   jresult = new Dali::Handle((const Dali::Handle &)result);
20104   return jresult;
20105 }
20106
20107
20108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20109   int jresult ;
20110   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20111   Dali::Property::Index result;
20112
20113   arg1 = (Dali::PropertyNotification *)jarg1;
20114   {
20115     try {
20116       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20117     } catch (std::out_of_range& e) {
20118       {
20119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20120       };
20121     } catch (std::exception& e) {
20122       {
20123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20124       };
20125     } catch (Dali::DaliException e) {
20126       {
20127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20128       };
20129     } catch (...) {
20130       {
20131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20132       };
20133     }
20134   }
20135
20136   jresult = result;
20137   return jresult;
20138 }
20139
20140
20141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20142   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20143   Dali::PropertyNotification::NotifyMode arg2 ;
20144
20145   arg1 = (Dali::PropertyNotification *)jarg1;
20146   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20147   {
20148     try {
20149       (arg1)->SetNotifyMode(arg2);
20150     } catch (std::out_of_range& e) {
20151       {
20152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20153       };
20154     } catch (std::exception& e) {
20155       {
20156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20157       };
20158     } catch (Dali::DaliException e) {
20159       {
20160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20161       };
20162     } catch (...) {
20163       {
20164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20165       };
20166     }
20167   }
20168
20169 }
20170
20171
20172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20173   int jresult ;
20174   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20175   Dali::PropertyNotification::NotifyMode result;
20176
20177   arg1 = (Dali::PropertyNotification *)jarg1;
20178   {
20179     try {
20180       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20181     } catch (std::out_of_range& e) {
20182       {
20183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20184       };
20185     } catch (std::exception& e) {
20186       {
20187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20188       };
20189     } catch (Dali::DaliException e) {
20190       {
20191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20192       };
20193     } catch (...) {
20194       {
20195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20196       };
20197     }
20198   }
20199
20200   jresult = (int)result;
20201   return jresult;
20202 }
20203
20204
20205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20206   unsigned int jresult ;
20207   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20208   bool result;
20209
20210   arg1 = (Dali::PropertyNotification *)jarg1;
20211   {
20212     try {
20213       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20214     } catch (std::out_of_range& e) {
20215       {
20216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20217       };
20218     } catch (std::exception& e) {
20219       {
20220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20221       };
20222     } catch (Dali::DaliException e) {
20223       {
20224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20225       };
20226     } catch (...) {
20227       {
20228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20229       };
20230     }
20231   }
20232
20233   jresult = result;
20234   return jresult;
20235 }
20236
20237
20238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20239   void * jresult ;
20240   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20241   Dali::PropertyNotifySignalType *result = 0 ;
20242
20243   arg1 = (Dali::PropertyNotification *)jarg1;
20244   {
20245     try {
20246       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20247     } catch (std::out_of_range& e) {
20248       {
20249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20250       };
20251     } catch (std::exception& e) {
20252       {
20253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20254       };
20255     } catch (Dali::DaliException e) {
20256       {
20257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20258       };
20259     } catch (...) {
20260       {
20261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20262       };
20263     }
20264   }
20265
20266   jresult = (void *)result;
20267   return jresult;
20268 }
20269
20270
20271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20272   void * jresult ;
20273   Dali::Handle *result = 0 ;
20274
20275   {
20276     try {
20277       result = (Dali::Handle *)new Dali::Handle();
20278     } catch (std::out_of_range& e) {
20279       {
20280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20281       };
20282     } catch (std::exception& e) {
20283       {
20284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20285       };
20286     } catch (Dali::DaliException e) {
20287       {
20288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20289       };
20290     } catch (...) {
20291       {
20292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20293       };
20294     }
20295   }
20296
20297   jresult = (void *)result;
20298   return jresult;
20299 }
20300
20301
20302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20303   void * jresult ;
20304   Dali::Handle result;
20305
20306   {
20307     try {
20308       result = Dali::Handle::New();
20309     } catch (std::out_of_range& e) {
20310       {
20311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20312       };
20313     } catch (std::exception& e) {
20314       {
20315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20316       };
20317     } catch (Dali::DaliException e) {
20318       {
20319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20320       };
20321     } catch (...) {
20322       {
20323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20324       };
20325     }
20326   }
20327
20328   jresult = new Dali::Handle((const Dali::Handle &)result);
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20334   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20335
20336   arg1 = (Dali::Handle *)jarg1;
20337   {
20338     try {
20339       delete arg1;
20340     } catch (std::out_of_range& e) {
20341       {
20342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20343       };
20344     } catch (std::exception& e) {
20345       {
20346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20347       };
20348     } catch (Dali::DaliException e) {
20349       {
20350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20351       };
20352     } catch (...) {
20353       {
20354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20355       };
20356     }
20357   }
20358
20359 }
20360
20361
20362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20363   void * jresult ;
20364   Dali::Handle *arg1 = 0 ;
20365   Dali::Handle *result = 0 ;
20366
20367   arg1 = (Dali::Handle *)jarg1;
20368   if (!arg1) {
20369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20370     return 0;
20371   }
20372   {
20373     try {
20374       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20375     } catch (std::out_of_range& e) {
20376       {
20377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20378       };
20379     } catch (std::exception& e) {
20380       {
20381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20382       };
20383     } catch (Dali::DaliException e) {
20384       {
20385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20386       };
20387     } catch (...) {
20388       {
20389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20390       };
20391     }
20392   }
20393
20394   jresult = (void *)result;
20395   return jresult;
20396 }
20397
20398
20399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20400   void * jresult ;
20401   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20402   Dali::Handle *arg2 = 0 ;
20403   Dali::Handle *result = 0 ;
20404
20405   arg1 = (Dali::Handle *)jarg1;
20406   arg2 = (Dali::Handle *)jarg2;
20407   if (!arg2) {
20408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20409     return 0;
20410   }
20411   {
20412     try {
20413       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20414     } catch (std::out_of_range& e) {
20415       {
20416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20417       };
20418     } catch (std::exception& e) {
20419       {
20420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20421       };
20422     } catch (Dali::DaliException e) {
20423       {
20424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20425       };
20426     } catch (...) {
20427       {
20428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20429       };
20430     }
20431   }
20432
20433   jresult = (void *)result;
20434   return jresult;
20435 }
20436
20437
20438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20439   void * jresult ;
20440   Dali::BaseHandle arg1 ;
20441   Dali::BaseHandle *argp1 ;
20442   Dali::Handle result;
20443
20444   argp1 = (Dali::BaseHandle *)jarg1;
20445   if (!argp1) {
20446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20447     return 0;
20448   }
20449   arg1 = *argp1;
20450   {
20451     try {
20452       result = Dali::Handle::DownCast(arg1);
20453     } catch (std::out_of_range& e) {
20454       {
20455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20456       };
20457     } catch (std::exception& e) {
20458       {
20459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20460       };
20461     } catch (Dali::DaliException e) {
20462       {
20463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20464       };
20465     } catch (...) {
20466       {
20467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20468       };
20469     }
20470   }
20471
20472   jresult = new Dali::Handle((const Dali::Handle &)result);
20473   return jresult;
20474 }
20475
20476
20477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20478   unsigned int jresult ;
20479   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20480   Dali::Handle::Capability arg2 ;
20481   bool result;
20482
20483   arg1 = (Dali::Handle *)jarg1;
20484   arg2 = (Dali::Handle::Capability)jarg2;
20485   {
20486     try {
20487       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20488     } catch (std::out_of_range& e) {
20489       {
20490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20491       };
20492     } catch (std::exception& e) {
20493       {
20494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20495       };
20496     } catch (Dali::DaliException e) {
20497       {
20498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20499       };
20500     } catch (...) {
20501       {
20502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20503       };
20504     }
20505   }
20506
20507   jresult = result;
20508   return jresult;
20509 }
20510
20511
20512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20513   unsigned int jresult ;
20514   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20515   unsigned int result;
20516
20517   arg1 = (Dali::Handle *)jarg1;
20518   {
20519     try {
20520       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20521     } catch (std::out_of_range& e) {
20522       {
20523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20524       };
20525     } catch (std::exception& e) {
20526       {
20527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20528       };
20529     } catch (Dali::DaliException e) {
20530       {
20531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20532       };
20533     } catch (...) {
20534       {
20535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20536       };
20537     }
20538   }
20539
20540   jresult = result;
20541   return jresult;
20542 }
20543
20544
20545 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20546   char * jresult ;
20547   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20548   Dali::Property::Index arg2 ;
20549   std::string result;
20550
20551   arg1 = (Dali::Handle *)jarg1;
20552   arg2 = (Dali::Property::Index)jarg2;
20553   {
20554     try {
20555       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20556     } catch (std::out_of_range& e) {
20557       {
20558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20559       };
20560     } catch (std::exception& e) {
20561       {
20562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20563       };
20564     } catch (Dali::DaliException e) {
20565       {
20566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20567       };
20568     } catch (...) {
20569       {
20570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20571       };
20572     }
20573   }
20574
20575   jresult = SWIG_csharp_string_callback((&result)->c_str());
20576   return jresult;
20577 }
20578
20579
20580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20581   int jresult ;
20582   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20583   std::string *arg2 = 0 ;
20584   Dali::Property::Index result;
20585
20586   arg1 = (Dali::Handle *)jarg1;
20587   if (!jarg2) {
20588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20589     return 0;
20590   }
20591   std::string arg2_str(jarg2);
20592   arg2 = &arg2_str;
20593   {
20594     try {
20595       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20596     } catch (std::out_of_range& e) {
20597       {
20598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20599       };
20600     } catch (std::exception& e) {
20601       {
20602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20603       };
20604     } catch (Dali::DaliException e) {
20605       {
20606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20607       };
20608     } catch (...) {
20609       {
20610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20611       };
20612     }
20613   }
20614
20615   jresult = result;
20616
20617   //argout typemap for const std::string&
20618
20619   return jresult;
20620 }
20621
20622
20623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20624   unsigned int jresult ;
20625   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20626   Dali::Property::Index arg2 ;
20627   bool result;
20628
20629   arg1 = (Dali::Handle *)jarg1;
20630   arg2 = (Dali::Property::Index)jarg2;
20631   {
20632     try {
20633       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20634     } catch (std::out_of_range& e) {
20635       {
20636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20637       };
20638     } catch (std::exception& e) {
20639       {
20640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20641       };
20642     } catch (Dali::DaliException e) {
20643       {
20644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20645       };
20646     } catch (...) {
20647       {
20648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20649       };
20650     }
20651   }
20652
20653   jresult = result;
20654   return jresult;
20655 }
20656
20657
20658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20659   unsigned int jresult ;
20660   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20661   Dali::Property::Index arg2 ;
20662   bool result;
20663
20664   arg1 = (Dali::Handle *)jarg1;
20665   arg2 = (Dali::Property::Index)jarg2;
20666   {
20667     try {
20668       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20669     } catch (std::out_of_range& e) {
20670       {
20671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20672       };
20673     } catch (std::exception& e) {
20674       {
20675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20676       };
20677     } catch (Dali::DaliException e) {
20678       {
20679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20680       };
20681     } catch (...) {
20682       {
20683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20684       };
20685     }
20686   }
20687
20688   jresult = result;
20689   return jresult;
20690 }
20691
20692
20693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20694   unsigned int jresult ;
20695   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20696   Dali::Property::Index arg2 ;
20697   bool result;
20698
20699   arg1 = (Dali::Handle *)jarg1;
20700   arg2 = (Dali::Property::Index)jarg2;
20701   {
20702     try {
20703       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20704     } catch (std::out_of_range& e) {
20705       {
20706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20707       };
20708     } catch (std::exception& e) {
20709       {
20710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20711       };
20712     } catch (Dali::DaliException e) {
20713       {
20714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20715       };
20716     } catch (...) {
20717       {
20718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20719       };
20720     }
20721   }
20722
20723   jresult = result;
20724   return jresult;
20725 }
20726
20727
20728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20729   int jresult ;
20730   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20731   Dali::Property::Index arg2 ;
20732   Dali::Property::Type result;
20733
20734   arg1 = (Dali::Handle *)jarg1;
20735   arg2 = (Dali::Property::Index)jarg2;
20736   {
20737     try {
20738       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20739     } catch (std::out_of_range& e) {
20740       {
20741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20742       };
20743     } catch (std::exception& e) {
20744       {
20745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20746       };
20747     } catch (Dali::DaliException e) {
20748       {
20749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20750       };
20751     } catch (...) {
20752       {
20753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20754       };
20755     }
20756   }
20757
20758   jresult = (int)result;
20759   return jresult;
20760 }
20761
20762
20763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20764   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20765   Dali::Property::Index arg2 ;
20766   Dali::Property::Value *arg3 = 0 ;
20767
20768   arg1 = (Dali::Handle *)jarg1;
20769   arg2 = (Dali::Property::Index)jarg2;
20770   arg3 = (Dali::Property::Value *)jarg3;
20771   if (!arg3) {
20772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20773     return ;
20774   }
20775   {
20776     try {
20777       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20778     } catch (std::out_of_range& e) {
20779       {
20780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20781       };
20782     } catch (std::exception& e) {
20783       {
20784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20785       };
20786     } catch (Dali::DaliException e) {
20787       {
20788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20789       };
20790     } catch (...) {
20791       {
20792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20793       };
20794     }
20795   }
20796
20797 }
20798
20799
20800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20801   int jresult ;
20802   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20803   std::string *arg2 = 0 ;
20804   Dali::Property::Value *arg3 = 0 ;
20805   Dali::Property::Index result;
20806
20807   arg1 = (Dali::Handle *)jarg1;
20808   if (!jarg2) {
20809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20810     return 0;
20811   }
20812   std::string arg2_str(jarg2);
20813   arg2 = &arg2_str;
20814   arg3 = (Dali::Property::Value *)jarg3;
20815   if (!arg3) {
20816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20817     return 0;
20818   }
20819   {
20820     try {
20821       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20822     } catch (std::out_of_range& e) {
20823       {
20824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20825       };
20826     } catch (std::exception& e) {
20827       {
20828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20829       };
20830     } catch (Dali::DaliException e) {
20831       {
20832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20833       };
20834     } catch (...) {
20835       {
20836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20837       };
20838     }
20839   }
20840
20841   jresult = result;
20842
20843   //argout typemap for const std::string&
20844
20845   return jresult;
20846 }
20847
20848
20849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20850   int jresult ;
20851   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20852   std::string *arg2 = 0 ;
20853   Dali::Property::Value *arg3 = 0 ;
20854   Dali::Property::AccessMode arg4 ;
20855   Dali::Property::Index result;
20856
20857   arg1 = (Dali::Handle *)jarg1;
20858   if (!jarg2) {
20859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20860     return 0;
20861   }
20862   std::string arg2_str(jarg2);
20863   arg2 = &arg2_str;
20864   arg3 = (Dali::Property::Value *)jarg3;
20865   if (!arg3) {
20866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20867     return 0;
20868   }
20869   arg4 = (Dali::Property::AccessMode)jarg4;
20870   {
20871     try {
20872       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20873     } catch (std::out_of_range& e) {
20874       {
20875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20876       };
20877     } catch (std::exception& e) {
20878       {
20879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20880       };
20881     } catch (Dali::DaliException e) {
20882       {
20883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20884       };
20885     } catch (...) {
20886       {
20887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20888       };
20889     }
20890   }
20891
20892   jresult = result;
20893
20894   //argout typemap for const std::string&
20895
20896   return jresult;
20897 }
20898
20899
20900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20901   void * jresult ;
20902   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20903   Dali::Property::Index arg2 ;
20904   Dali::Property::Value result;
20905
20906   arg1 = (Dali::Handle *)jarg1;
20907   arg2 = (Dali::Property::Index)jarg2;
20908   {
20909     try {
20910       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20911     } catch (std::out_of_range& e) {
20912       {
20913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20914       };
20915     } catch (std::exception& e) {
20916       {
20917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20918       };
20919     } catch (Dali::DaliException e) {
20920       {
20921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20922       };
20923     } catch (...) {
20924       {
20925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20926       };
20927     }
20928   }
20929
20930   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20931   return jresult;
20932 }
20933
20934
20935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20936   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20937   Dali::Property::IndexContainer *arg2 = 0 ;
20938
20939   arg1 = (Dali::Handle *)jarg1;
20940   arg2 = (Dali::Property::IndexContainer *)jarg2;
20941   if (!arg2) {
20942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20943     return ;
20944   }
20945   {
20946     try {
20947       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20948     } catch (std::out_of_range& e) {
20949       {
20950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20951       };
20952     } catch (std::exception& e) {
20953       {
20954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20955       };
20956     } catch (Dali::DaliException e) {
20957       {
20958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20959       };
20960     } catch (...) {
20961       {
20962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20963       };
20964     }
20965   }
20966
20967 }
20968
20969
20970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20971   void * jresult ;
20972   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20973   Dali::Property::Index arg2 ;
20974   Dali::PropertyCondition *arg3 = 0 ;
20975   Dali::PropertyNotification result;
20976
20977   arg1 = (Dali::Handle *)jarg1;
20978   arg2 = (Dali::Property::Index)jarg2;
20979   arg3 = (Dali::PropertyCondition *)jarg3;
20980   if (!arg3) {
20981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20982     return 0;
20983   }
20984   {
20985     try {
20986       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20987     } catch (std::out_of_range& e) {
20988       {
20989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (std::exception& e) {
20992       {
20993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20994       };
20995     } catch (Dali::DaliException e) {
20996       {
20997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20998       };
20999     } catch (...) {
21000       {
21001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21002       };
21003     }
21004   }
21005
21006   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21007   return jresult;
21008 }
21009
21010
21011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21012   void * jresult ;
21013   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21014   Dali::Property::Index arg2 ;
21015   int arg3 ;
21016   Dali::PropertyCondition *arg4 = 0 ;
21017   Dali::PropertyNotification result;
21018
21019   arg1 = (Dali::Handle *)jarg1;
21020   arg2 = (Dali::Property::Index)jarg2;
21021   arg3 = (int)jarg3;
21022   arg4 = (Dali::PropertyCondition *)jarg4;
21023   if (!arg4) {
21024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21025     return 0;
21026   }
21027   {
21028     try {
21029       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21030     } catch (std::out_of_range& e) {
21031       {
21032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21033       };
21034     } catch (std::exception& e) {
21035       {
21036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21037       };
21038     } catch (Dali::DaliException e) {
21039       {
21040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21041       };
21042     } catch (...) {
21043       {
21044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21045       };
21046     }
21047   }
21048
21049   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21050   return jresult;
21051 }
21052
21053
21054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21055   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21056   Dali::PropertyNotification arg2 ;
21057   Dali::PropertyNotification *argp2 ;
21058
21059   arg1 = (Dali::Handle *)jarg1;
21060   argp2 = (Dali::PropertyNotification *)jarg2;
21061   if (!argp2) {
21062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21063     return ;
21064   }
21065   arg2 = *argp2;
21066   {
21067     try {
21068       (arg1)->RemovePropertyNotification(arg2);
21069     } catch (std::out_of_range& e) {
21070       {
21071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21072       };
21073     } catch (std::exception& e) {
21074       {
21075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21076       };
21077     } catch (Dali::DaliException e) {
21078       {
21079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21080       };
21081     } catch (...) {
21082       {
21083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21084       };
21085     }
21086   }
21087
21088 }
21089
21090
21091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21092   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21093
21094   arg1 = (Dali::Handle *)jarg1;
21095   {
21096     try {
21097       (arg1)->RemovePropertyNotifications();
21098     } catch (std::out_of_range& e) {
21099       {
21100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21101       };
21102     } catch (std::exception& e) {
21103       {
21104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21105       };
21106     } catch (Dali::DaliException e) {
21107       {
21108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21109       };
21110     } catch (...) {
21111       {
21112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21113       };
21114     }
21115   }
21116
21117 }
21118
21119
21120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21121   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21122
21123   arg1 = (Dali::Handle *)jarg1;
21124   {
21125     try {
21126       (arg1)->RemoveConstraints();
21127     } catch (std::out_of_range& e) {
21128       {
21129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21130       };
21131     } catch (std::exception& e) {
21132       {
21133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21134       };
21135     } catch (Dali::DaliException e) {
21136       {
21137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21138       };
21139     } catch (...) {
21140       {
21141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21142       };
21143     }
21144   }
21145
21146 }
21147
21148
21149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21150   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21151   unsigned int arg2 ;
21152
21153   arg1 = (Dali::Handle *)jarg1;
21154   arg2 = (unsigned int)jarg2;
21155   {
21156     try {
21157       (arg1)->RemoveConstraints(arg2);
21158     } catch (std::out_of_range& e) {
21159       {
21160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21161       };
21162     } catch (std::exception& e) {
21163       {
21164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21165       };
21166     } catch (Dali::DaliException e) {
21167       {
21168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21169       };
21170     } catch (...) {
21171       {
21172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21173       };
21174     }
21175   }
21176
21177 }
21178
21179
21180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21181   int jresult ;
21182   Dali::Property::Index result;
21183
21184   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21185   jresult = result;
21186   return jresult;
21187 }
21188
21189
21190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21191   void * jresult ;
21192   Dali::Handle result;
21193
21194   {
21195     try {
21196       result = Dali::WeightObject::New();
21197     } catch (std::out_of_range& e) {
21198       {
21199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21200       };
21201     } catch (std::exception& e) {
21202       {
21203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21204       };
21205     } catch (Dali::DaliException e) {
21206       {
21207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21208       };
21209     } catch (...) {
21210       {
21211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21212       };
21213     }
21214   }
21215
21216   jresult = new Dali::Handle((const Dali::Handle &)result);
21217   return jresult;
21218 }
21219
21220
21221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21222   void * jresult ;
21223   Dali::TypeInfo *result = 0 ;
21224
21225   {
21226     try {
21227       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21228     } catch (std::out_of_range& e) {
21229       {
21230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21231       };
21232     } catch (std::exception& e) {
21233       {
21234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21235       };
21236     } catch (Dali::DaliException e) {
21237       {
21238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21239       };
21240     } catch (...) {
21241       {
21242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21243       };
21244     }
21245   }
21246
21247   jresult = (void *)result;
21248   return jresult;
21249 }
21250
21251
21252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21253   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21254
21255   arg1 = (Dali::TypeInfo *)jarg1;
21256   {
21257     try {
21258       delete arg1;
21259     } catch (std::out_of_range& e) {
21260       {
21261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21262       };
21263     } catch (std::exception& e) {
21264       {
21265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21266       };
21267     } catch (Dali::DaliException e) {
21268       {
21269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21270       };
21271     } catch (...) {
21272       {
21273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21274       };
21275     }
21276   }
21277
21278 }
21279
21280
21281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21282   void * jresult ;
21283   Dali::TypeInfo *arg1 = 0 ;
21284   Dali::TypeInfo *result = 0 ;
21285
21286   arg1 = (Dali::TypeInfo *)jarg1;
21287   if (!arg1) {
21288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21289     return 0;
21290   }
21291   {
21292     try {
21293       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21294     } catch (std::out_of_range& e) {
21295       {
21296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21297       };
21298     } catch (std::exception& e) {
21299       {
21300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21301       };
21302     } catch (Dali::DaliException e) {
21303       {
21304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21305       };
21306     } catch (...) {
21307       {
21308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21309       };
21310     }
21311   }
21312
21313   jresult = (void *)result;
21314   return jresult;
21315 }
21316
21317
21318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21319   void * jresult ;
21320   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21321   Dali::TypeInfo *arg2 = 0 ;
21322   Dali::TypeInfo *result = 0 ;
21323
21324   arg1 = (Dali::TypeInfo *)jarg1;
21325   arg2 = (Dali::TypeInfo *)jarg2;
21326   if (!arg2) {
21327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21328     return 0;
21329   }
21330   {
21331     try {
21332       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21333     } catch (std::out_of_range& e) {
21334       {
21335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21336       };
21337     } catch (std::exception& e) {
21338       {
21339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21340       };
21341     } catch (Dali::DaliException e) {
21342       {
21343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21344       };
21345     } catch (...) {
21346       {
21347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21348       };
21349     }
21350   }
21351
21352   jresult = (void *)result;
21353   return jresult;
21354 }
21355
21356
21357 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21358   char * jresult ;
21359   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21360   std::string *result = 0 ;
21361
21362   arg1 = (Dali::TypeInfo *)jarg1;
21363   {
21364     try {
21365       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21366     } catch (std::out_of_range& e) {
21367       {
21368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21369       };
21370     } catch (std::exception& e) {
21371       {
21372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21373       };
21374     } catch (Dali::DaliException e) {
21375       {
21376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21377       };
21378     } catch (...) {
21379       {
21380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21381       };
21382     }
21383   }
21384
21385   jresult = SWIG_csharp_string_callback(result->c_str());
21386   return jresult;
21387 }
21388
21389
21390 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21391   char * jresult ;
21392   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21393   std::string *result = 0 ;
21394
21395   arg1 = (Dali::TypeInfo *)jarg1;
21396   {
21397     try {
21398       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21399     } catch (std::out_of_range& e) {
21400       {
21401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21402       };
21403     } catch (std::exception& e) {
21404       {
21405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21406       };
21407     } catch (Dali::DaliException e) {
21408       {
21409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21410       };
21411     } catch (...) {
21412       {
21413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21414       };
21415     }
21416   }
21417
21418   jresult = SWIG_csharp_string_callback(result->c_str());
21419   return jresult;
21420 }
21421
21422
21423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21424   void * jresult ;
21425   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21426   Dali::BaseHandle result;
21427
21428   arg1 = (Dali::TypeInfo *)jarg1;
21429   {
21430     try {
21431       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21432     } catch (std::out_of_range& e) {
21433       {
21434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21435       };
21436     } catch (std::exception& e) {
21437       {
21438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21439       };
21440     } catch (Dali::DaliException e) {
21441       {
21442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21443       };
21444     } catch (...) {
21445       {
21446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21447       };
21448     }
21449   }
21450
21451   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21452   return jresult;
21453 }
21454
21455
21456 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21457   unsigned long jresult ;
21458   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21459   size_t result;
21460
21461   arg1 = (Dali::TypeInfo *)jarg1;
21462   {
21463     try {
21464       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21465     } catch (std::out_of_range& e) {
21466       {
21467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21468       };
21469     } catch (std::exception& e) {
21470       {
21471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21472       };
21473     } catch (Dali::DaliException e) {
21474       {
21475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21476       };
21477     } catch (...) {
21478       {
21479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21480       };
21481     }
21482   }
21483
21484   jresult = (unsigned long)result;
21485   return jresult;
21486 }
21487
21488
21489 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21490   char * jresult ;
21491   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21492   size_t arg2 ;
21493   std::string result;
21494
21495   arg1 = (Dali::TypeInfo *)jarg1;
21496   arg2 = (size_t)jarg2;
21497   {
21498     try {
21499       result = (arg1)->GetActionName(arg2);
21500     } catch (std::out_of_range& e) {
21501       {
21502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21503       };
21504     } catch (std::exception& e) {
21505       {
21506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21507       };
21508     } catch (Dali::DaliException e) {
21509       {
21510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21511       };
21512     } catch (...) {
21513       {
21514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21515       };
21516     }
21517   }
21518
21519   jresult = SWIG_csharp_string_callback((&result)->c_str());
21520   return jresult;
21521 }
21522
21523
21524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21525   unsigned long jresult ;
21526   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21527   size_t result;
21528
21529   arg1 = (Dali::TypeInfo *)jarg1;
21530   {
21531     try {
21532       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21533     } catch (std::out_of_range& e) {
21534       {
21535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21536       };
21537     } catch (std::exception& e) {
21538       {
21539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21540       };
21541     } catch (Dali::DaliException e) {
21542       {
21543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21544       };
21545     } catch (...) {
21546       {
21547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21548       };
21549     }
21550   }
21551
21552   jresult = (unsigned long)result;
21553   return jresult;
21554 }
21555
21556
21557 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21558   char * jresult ;
21559   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21560   size_t arg2 ;
21561   std::string result;
21562
21563   arg1 = (Dali::TypeInfo *)jarg1;
21564   arg2 = (size_t)jarg2;
21565   {
21566     try {
21567       result = (arg1)->GetSignalName(arg2);
21568     } catch (std::out_of_range& e) {
21569       {
21570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21571       };
21572     } catch (std::exception& e) {
21573       {
21574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21575       };
21576     } catch (Dali::DaliException e) {
21577       {
21578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21579       };
21580     } catch (...) {
21581       {
21582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21583       };
21584     }
21585   }
21586
21587   jresult = SWIG_csharp_string_callback((&result)->c_str());
21588   return jresult;
21589 }
21590
21591
21592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21593   unsigned long jresult ;
21594   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21595   size_t result;
21596
21597   arg1 = (Dali::TypeInfo *)jarg1;
21598   {
21599     try {
21600       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21601     } catch (std::out_of_range& e) {
21602       {
21603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21604       };
21605     } catch (std::exception& e) {
21606       {
21607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21608       };
21609     } catch (Dali::DaliException e) {
21610       {
21611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21612       };
21613     } catch (...) {
21614       {
21615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21616       };
21617     }
21618   }
21619
21620   jresult = (unsigned long)result;
21621   return jresult;
21622 }
21623
21624
21625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21626   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21627   Dali::Property::IndexContainer *arg2 = 0 ;
21628
21629   arg1 = (Dali::TypeInfo *)jarg1;
21630   arg2 = (Dali::Property::IndexContainer *)jarg2;
21631   if (!arg2) {
21632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21633     return ;
21634   }
21635   {
21636     try {
21637       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21638     } catch (std::out_of_range& e) {
21639       {
21640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21641       };
21642     } catch (std::exception& e) {
21643       {
21644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21645       };
21646     } catch (Dali::DaliException e) {
21647       {
21648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21649       };
21650     } catch (...) {
21651       {
21652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21653       };
21654     }
21655   }
21656
21657 }
21658
21659
21660 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21661   char * jresult ;
21662   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21663   Dali::Property::Index arg2 ;
21664   std::string *result = 0 ;
21665
21666   arg1 = (Dali::TypeInfo *)jarg1;
21667   arg2 = (Dali::Property::Index)jarg2;
21668   {
21669     try {
21670       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21671     } catch (std::out_of_range& e) {
21672       {
21673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21674       };
21675     } catch (std::exception& e) {
21676       {
21677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21678       };
21679     } catch (Dali::DaliException e) {
21680       {
21681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21682       };
21683     } catch (...) {
21684       {
21685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21686       };
21687     }
21688   }
21689
21690   jresult = SWIG_csharp_string_callback(result->c_str());
21691   return jresult;
21692 }
21693
21694
21695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21696   void * jresult ;
21697   Dali::TypeRegistry result;
21698
21699   {
21700     try {
21701       result = Dali::TypeRegistry::Get();
21702     } catch (std::out_of_range& e) {
21703       {
21704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21705       };
21706     } catch (std::exception& e) {
21707       {
21708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21709       };
21710     } catch (Dali::DaliException e) {
21711       {
21712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21713       };
21714     } catch (...) {
21715       {
21716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21717       };
21718     }
21719   }
21720
21721   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21722   return jresult;
21723 }
21724
21725
21726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21727   void * jresult ;
21728   Dali::TypeRegistry *result = 0 ;
21729
21730   {
21731     try {
21732       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21733     } catch (std::out_of_range& e) {
21734       {
21735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21736       };
21737     } catch (std::exception& e) {
21738       {
21739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21740       };
21741     } catch (Dali::DaliException e) {
21742       {
21743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21744       };
21745     } catch (...) {
21746       {
21747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21748       };
21749     }
21750   }
21751
21752   jresult = (void *)result;
21753   return jresult;
21754 }
21755
21756
21757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21758   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21759
21760   arg1 = (Dali::TypeRegistry *)jarg1;
21761   {
21762     try {
21763       delete arg1;
21764     } catch (std::out_of_range& e) {
21765       {
21766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21767       };
21768     } catch (std::exception& e) {
21769       {
21770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21771       };
21772     } catch (Dali::DaliException e) {
21773       {
21774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21775       };
21776     } catch (...) {
21777       {
21778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21779       };
21780     }
21781   }
21782
21783 }
21784
21785
21786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21787   void * jresult ;
21788   Dali::TypeRegistry *arg1 = 0 ;
21789   Dali::TypeRegistry *result = 0 ;
21790
21791   arg1 = (Dali::TypeRegistry *)jarg1;
21792   if (!arg1) {
21793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21794     return 0;
21795   }
21796   {
21797     try {
21798       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21799     } catch (std::out_of_range& e) {
21800       {
21801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21802       };
21803     } catch (std::exception& e) {
21804       {
21805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21806       };
21807     } catch (Dali::DaliException e) {
21808       {
21809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21810       };
21811     } catch (...) {
21812       {
21813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21814       };
21815     }
21816   }
21817
21818   jresult = (void *)result;
21819   return jresult;
21820 }
21821
21822
21823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21824   void * jresult ;
21825   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21826   Dali::TypeRegistry *arg2 = 0 ;
21827   Dali::TypeRegistry *result = 0 ;
21828
21829   arg1 = (Dali::TypeRegistry *)jarg1;
21830   arg2 = (Dali::TypeRegistry *)jarg2;
21831   if (!arg2) {
21832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21833     return 0;
21834   }
21835   {
21836     try {
21837       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21838     } catch (std::out_of_range& e) {
21839       {
21840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21841       };
21842     } catch (std::exception& e) {
21843       {
21844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21845       };
21846     } catch (Dali::DaliException e) {
21847       {
21848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21849       };
21850     } catch (...) {
21851       {
21852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21853       };
21854     }
21855   }
21856
21857   jresult = (void *)result;
21858   return jresult;
21859 }
21860
21861
21862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21863   void * jresult ;
21864   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21865   std::string *arg2 = 0 ;
21866   Dali::TypeInfo result;
21867
21868   arg1 = (Dali::TypeRegistry *)jarg1;
21869   if (!jarg2) {
21870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21871     return 0;
21872   }
21873   std::string arg2_str(jarg2);
21874   arg2 = &arg2_str;
21875   {
21876     try {
21877       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21878     } catch (std::out_of_range& e) {
21879       {
21880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21881       };
21882     } catch (std::exception& e) {
21883       {
21884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21885       };
21886     } catch (Dali::DaliException e) {
21887       {
21888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21889       };
21890     } catch (...) {
21891       {
21892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21893       };
21894     }
21895   }
21896
21897   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21898
21899   //argout typemap for const std::string&
21900
21901   return jresult;
21902 }
21903
21904
21905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21906   void * jresult ;
21907   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21908   std::type_info *arg2 = 0 ;
21909   Dali::TypeInfo result;
21910
21911   arg1 = (Dali::TypeRegistry *)jarg1;
21912   arg2 = (std::type_info *)jarg2;
21913   if (!arg2) {
21914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21915     return 0;
21916   }
21917   {
21918     try {
21919       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21920     } catch (std::out_of_range& e) {
21921       {
21922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21923       };
21924     } catch (std::exception& e) {
21925       {
21926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21927       };
21928     } catch (Dali::DaliException e) {
21929       {
21930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21931       };
21932     } catch (...) {
21933       {
21934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21935       };
21936     }
21937   }
21938
21939   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21940   return jresult;
21941 }
21942
21943
21944 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21945   unsigned long jresult ;
21946   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21947   size_t result;
21948
21949   arg1 = (Dali::TypeRegistry *)jarg1;
21950   {
21951     try {
21952       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21953     } catch (std::out_of_range& e) {
21954       {
21955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21956       };
21957     } catch (std::exception& e) {
21958       {
21959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21960       };
21961     } catch (Dali::DaliException e) {
21962       {
21963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21964       };
21965     } catch (...) {
21966       {
21967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21968       };
21969     }
21970   }
21971
21972   jresult = (unsigned long)result;
21973   return jresult;
21974 }
21975
21976
21977 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21978   char * jresult ;
21979   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21980   size_t arg2 ;
21981   std::string result;
21982
21983   arg1 = (Dali::TypeRegistry *)jarg1;
21984   arg2 = (size_t)jarg2;
21985   {
21986     try {
21987       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21988     } catch (std::out_of_range& e) {
21989       {
21990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21991       };
21992     } catch (std::exception& e) {
21993       {
21994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21995       };
21996     } catch (Dali::DaliException e) {
21997       {
21998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21999       };
22000     } catch (...) {
22001       {
22002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22003       };
22004     }
22005   }
22006
22007   jresult = SWIG_csharp_string_callback((&result)->c_str());
22008   return jresult;
22009 }
22010
22011
22012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22013   void * jresult ;
22014   std::type_info *arg1 = 0 ;
22015   std::type_info *arg2 = 0 ;
22016   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22017   Dali::TypeRegistration *result = 0 ;
22018
22019   arg1 = (std::type_info *)jarg1;
22020   if (!arg1) {
22021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22022     return 0;
22023   }
22024   arg2 = (std::type_info *)jarg2;
22025   if (!arg2) {
22026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22027     return 0;
22028   }
22029   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22030   {
22031     try {
22032       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22033     } catch (std::out_of_range& e) {
22034       {
22035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22036       };
22037     } catch (std::exception& e) {
22038       {
22039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22040       };
22041     } catch (Dali::DaliException e) {
22042       {
22043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22044       };
22045     } catch (...) {
22046       {
22047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22048       };
22049     }
22050   }
22051
22052   jresult = (void *)result;
22053   return jresult;
22054 }
22055
22056
22057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22058   void * jresult ;
22059   std::type_info *arg1 = 0 ;
22060   std::type_info *arg2 = 0 ;
22061   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22062   bool arg4 ;
22063   Dali::TypeRegistration *result = 0 ;
22064
22065   arg1 = (std::type_info *)jarg1;
22066   if (!arg1) {
22067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22068     return 0;
22069   }
22070   arg2 = (std::type_info *)jarg2;
22071   if (!arg2) {
22072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22073     return 0;
22074   }
22075   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22076   arg4 = jarg4 ? true : false;
22077   {
22078     try {
22079       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22080     } catch (std::out_of_range& e) {
22081       {
22082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22083       };
22084     } catch (std::exception& e) {
22085       {
22086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22087       };
22088     } catch (Dali::DaliException e) {
22089       {
22090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22091       };
22092     } catch (...) {
22093       {
22094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22095       };
22096     }
22097   }
22098
22099   jresult = (void *)result;
22100   return jresult;
22101 }
22102
22103
22104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22105   void * jresult ;
22106   std::string *arg1 = 0 ;
22107   std::type_info *arg2 = 0 ;
22108   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22109   Dali::TypeRegistration *result = 0 ;
22110
22111   if (!jarg1) {
22112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22113     return 0;
22114   }
22115   std::string arg1_str(jarg1);
22116   arg1 = &arg1_str;
22117   arg2 = (std::type_info *)jarg2;
22118   if (!arg2) {
22119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22120     return 0;
22121   }
22122   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22123   {
22124     try {
22125       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22126     } catch (std::out_of_range& e) {
22127       {
22128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22129       };
22130     } catch (std::exception& e) {
22131       {
22132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22133       };
22134     } catch (Dali::DaliException e) {
22135       {
22136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22137       };
22138     } catch (...) {
22139       {
22140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22141       };
22142     }
22143   }
22144
22145   jresult = (void *)result;
22146
22147   //argout typemap for const std::string&
22148
22149   return jresult;
22150 }
22151
22152
22153 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22154   char * jresult ;
22155   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22156   std::string result;
22157
22158   arg1 = (Dali::TypeRegistration *)jarg1;
22159   {
22160     try {
22161       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22162     } catch (std::out_of_range& e) {
22163       {
22164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22165       };
22166     } catch (std::exception& e) {
22167       {
22168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22169       };
22170     } catch (Dali::DaliException e) {
22171       {
22172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22173       };
22174     } catch (...) {
22175       {
22176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22177       };
22178     }
22179   }
22180
22181   jresult = SWIG_csharp_string_callback((&result)->c_str());
22182   return jresult;
22183 }
22184
22185
22186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22187   std::string *arg1 = 0 ;
22188   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22189
22190   if (!jarg1) {
22191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22192     return ;
22193   }
22194   std::string arg1_str(jarg1);
22195   arg1 = &arg1_str;
22196   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22197   {
22198     try {
22199       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22200     } catch (std::out_of_range& e) {
22201       {
22202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22203       };
22204     } catch (std::exception& e) {
22205       {
22206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22207       };
22208     } catch (Dali::DaliException e) {
22209       {
22210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22211       };
22212     } catch (...) {
22213       {
22214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22215       };
22216     }
22217   }
22218
22219
22220   //argout typemap for const std::string&
22221
22222 }
22223
22224
22225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22226   std::string *arg1 = 0 ;
22227   std::string *arg2 = 0 ;
22228   int arg3 ;
22229   Dali::Property::Type arg4 ;
22230   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22231   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22232
22233   if (!jarg1) {
22234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22235     return ;
22236   }
22237   std::string arg1_str(jarg1);
22238   arg1 = &arg1_str;
22239   if (!jarg2) {
22240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22241     return ;
22242   }
22243   std::string arg2_str(jarg2);
22244   arg2 = &arg2_str;
22245   arg3 = (int)jarg3;
22246   arg4 = (Dali::Property::Type)jarg4;
22247   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22248   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22249   {
22250     try {
22251       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22252     } catch (std::out_of_range& e) {
22253       {
22254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22255       };
22256     } catch (std::exception& e) {
22257       {
22258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22259       };
22260     } catch (Dali::DaliException e) {
22261       {
22262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22263       };
22264     } catch (...) {
22265       {
22266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22267       };
22268     }
22269   }
22270
22271
22272   //argout typemap for const std::string&
22273
22274
22275   //argout typemap for const std::string&
22276
22277 }
22278
22279
22280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22281   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22282
22283   arg1 = (Dali::TypeRegistration *)jarg1;
22284   {
22285     try {
22286       delete arg1;
22287     } catch (std::out_of_range& e) {
22288       {
22289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22290       };
22291     } catch (std::exception& e) {
22292       {
22293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22294       };
22295     } catch (Dali::DaliException e) {
22296       {
22297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22298       };
22299     } catch (...) {
22300       {
22301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22302       };
22303     }
22304   }
22305
22306 }
22307
22308
22309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22310   void * jresult ;
22311   Dali::TypeRegistration *arg1 = 0 ;
22312   std::string *arg2 = 0 ;
22313   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22314   Dali::SignalConnectorType *result = 0 ;
22315
22316   arg1 = (Dali::TypeRegistration *)jarg1;
22317   if (!arg1) {
22318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22319     return 0;
22320   }
22321   if (!jarg2) {
22322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22323     return 0;
22324   }
22325   std::string arg2_str(jarg2);
22326   arg2 = &arg2_str;
22327   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22328   {
22329     try {
22330       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22331     } catch (std::out_of_range& e) {
22332       {
22333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22334       };
22335     } catch (std::exception& e) {
22336       {
22337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22338       };
22339     } catch (Dali::DaliException e) {
22340       {
22341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22342       };
22343     } catch (...) {
22344       {
22345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22346       };
22347     }
22348   }
22349
22350   jresult = (void *)result;
22351
22352   //argout typemap for const std::string&
22353
22354   return jresult;
22355 }
22356
22357
22358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22359   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22360
22361   arg1 = (Dali::SignalConnectorType *)jarg1;
22362   {
22363     try {
22364       delete arg1;
22365     } catch (std::out_of_range& e) {
22366       {
22367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22368       };
22369     } catch (std::exception& e) {
22370       {
22371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22372       };
22373     } catch (Dali::DaliException e) {
22374       {
22375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22376       };
22377     } catch (...) {
22378       {
22379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22380       };
22381     }
22382   }
22383
22384 }
22385
22386
22387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22388   void * jresult ;
22389   Dali::TypeRegistration *arg1 = 0 ;
22390   std::string *arg2 = 0 ;
22391   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22392   Dali::TypeAction *result = 0 ;
22393
22394   arg1 = (Dali::TypeRegistration *)jarg1;
22395   if (!arg1) {
22396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22397     return 0;
22398   }
22399   if (!jarg2) {
22400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22401     return 0;
22402   }
22403   std::string arg2_str(jarg2);
22404   arg2 = &arg2_str;
22405   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22406   {
22407     try {
22408       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22409     } catch (std::out_of_range& e) {
22410       {
22411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22412       };
22413     } catch (std::exception& e) {
22414       {
22415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22416       };
22417     } catch (Dali::DaliException e) {
22418       {
22419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22420       };
22421     } catch (...) {
22422       {
22423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22424       };
22425     }
22426   }
22427
22428   jresult = (void *)result;
22429
22430   //argout typemap for const std::string&
22431
22432   return jresult;
22433 }
22434
22435
22436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22437   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22438
22439   arg1 = (Dali::TypeAction *)jarg1;
22440   {
22441     try {
22442       delete arg1;
22443     } catch (std::out_of_range& e) {
22444       {
22445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22446       };
22447     } catch (std::exception& e) {
22448       {
22449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22450       };
22451     } catch (Dali::DaliException e) {
22452       {
22453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22454       };
22455     } catch (...) {
22456       {
22457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22458       };
22459     }
22460   }
22461
22462 }
22463
22464
22465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22466   void * jresult ;
22467   Dali::TypeRegistration *arg1 = 0 ;
22468   std::string *arg2 = 0 ;
22469   Dali::Property::Index arg3 ;
22470   Dali::Property::Type arg4 ;
22471   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22472   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22473   Dali::PropertyRegistration *result = 0 ;
22474
22475   arg1 = (Dali::TypeRegistration *)jarg1;
22476   if (!arg1) {
22477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22478     return 0;
22479   }
22480   if (!jarg2) {
22481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22482     return 0;
22483   }
22484   std::string arg2_str(jarg2);
22485   arg2 = &arg2_str;
22486   arg3 = (Dali::Property::Index)jarg3;
22487   arg4 = (Dali::Property::Type)jarg4;
22488   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22489   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22490   {
22491     try {
22492       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22493     } catch (std::out_of_range& e) {
22494       {
22495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22496       };
22497     } catch (std::exception& e) {
22498       {
22499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22500       };
22501     } catch (Dali::DaliException e) {
22502       {
22503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22504       };
22505     } catch (...) {
22506       {
22507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22508       };
22509     }
22510   }
22511
22512   jresult = (void *)result;
22513
22514   //argout typemap for const std::string&
22515
22516   return jresult;
22517 }
22518
22519
22520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22521   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22522
22523   arg1 = (Dali::PropertyRegistration *)jarg1;
22524   {
22525     try {
22526       delete arg1;
22527     } catch (std::out_of_range& e) {
22528       {
22529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22530       };
22531     } catch (std::exception& e) {
22532       {
22533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22534       };
22535     } catch (Dali::DaliException e) {
22536       {
22537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22538       };
22539     } catch (...) {
22540       {
22541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22542       };
22543     }
22544   }
22545
22546 }
22547
22548
22549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22550   void * jresult ;
22551   Dali::TypeRegistration *arg1 = 0 ;
22552   std::string *arg2 = 0 ;
22553   Dali::Property::Index arg3 ;
22554   Dali::Property::Type arg4 ;
22555   Dali::AnimatablePropertyRegistration *result = 0 ;
22556
22557   arg1 = (Dali::TypeRegistration *)jarg1;
22558   if (!arg1) {
22559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22560     return 0;
22561   }
22562   if (!jarg2) {
22563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22564     return 0;
22565   }
22566   std::string arg2_str(jarg2);
22567   arg2 = &arg2_str;
22568   arg3 = (Dali::Property::Index)jarg3;
22569   arg4 = (Dali::Property::Type)jarg4;
22570   {
22571     try {
22572       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22573     } catch (std::out_of_range& e) {
22574       {
22575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22576       };
22577     } catch (std::exception& e) {
22578       {
22579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22580       };
22581     } catch (Dali::DaliException e) {
22582       {
22583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22584       };
22585     } catch (...) {
22586       {
22587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22588       };
22589     }
22590   }
22591
22592   jresult = (void *)result;
22593
22594   //argout typemap for const std::string&
22595
22596   return jresult;
22597 }
22598
22599
22600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22601   void * jresult ;
22602   Dali::TypeRegistration *arg1 = 0 ;
22603   std::string *arg2 = 0 ;
22604   Dali::Property::Index arg3 ;
22605   Dali::Property::Value *arg4 = 0 ;
22606   Dali::AnimatablePropertyRegistration *result = 0 ;
22607
22608   arg1 = (Dali::TypeRegistration *)jarg1;
22609   if (!arg1) {
22610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22611     return 0;
22612   }
22613   if (!jarg2) {
22614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22615     return 0;
22616   }
22617   std::string arg2_str(jarg2);
22618   arg2 = &arg2_str;
22619   arg3 = (Dali::Property::Index)jarg3;
22620   arg4 = (Dali::Property::Value *)jarg4;
22621   if (!arg4) {
22622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22623     return 0;
22624   }
22625   {
22626     try {
22627       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22628     } catch (std::out_of_range& e) {
22629       {
22630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22631       };
22632     } catch (std::exception& e) {
22633       {
22634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22635       };
22636     } catch (Dali::DaliException e) {
22637       {
22638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22639       };
22640     } catch (...) {
22641       {
22642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22643       };
22644     }
22645   }
22646
22647   jresult = (void *)result;
22648
22649   //argout typemap for const std::string&
22650
22651   return jresult;
22652 }
22653
22654
22655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22656   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22657
22658   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22659   {
22660     try {
22661       delete arg1;
22662     } catch (std::out_of_range& e) {
22663       {
22664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22665       };
22666     } catch (std::exception& e) {
22667       {
22668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22669       };
22670     } catch (Dali::DaliException e) {
22671       {
22672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22673       };
22674     } catch (...) {
22675       {
22676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22677       };
22678     }
22679   }
22680
22681 }
22682
22683
22684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22685   void * jresult ;
22686   Dali::TypeRegistration *arg1 = 0 ;
22687   std::string *arg2 = 0 ;
22688   Dali::Property::Index arg3 ;
22689   Dali::Property::Index arg4 ;
22690   unsigned int arg5 ;
22691   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22692
22693   arg1 = (Dali::TypeRegistration *)jarg1;
22694   if (!arg1) {
22695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22696     return 0;
22697   }
22698   if (!jarg2) {
22699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22700     return 0;
22701   }
22702   std::string arg2_str(jarg2);
22703   arg2 = &arg2_str;
22704   arg3 = (Dali::Property::Index)jarg3;
22705   arg4 = (Dali::Property::Index)jarg4;
22706   arg5 = (unsigned int)jarg5;
22707   {
22708     try {
22709       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22710     } catch (std::out_of_range& e) {
22711       {
22712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22713       };
22714     } catch (std::exception& e) {
22715       {
22716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22717       };
22718     } catch (Dali::DaliException e) {
22719       {
22720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22721       };
22722     } catch (...) {
22723       {
22724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22725       };
22726     }
22727   }
22728
22729   jresult = (void *)result;
22730
22731   //argout typemap for const std::string&
22732
22733   return jresult;
22734 }
22735
22736
22737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22738   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22739
22740   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22741   {
22742     try {
22743       delete arg1;
22744     } catch (std::out_of_range& e) {
22745       {
22746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22747       };
22748     } catch (std::exception& e) {
22749       {
22750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22751       };
22752     } catch (Dali::DaliException e) {
22753       {
22754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22755       };
22756     } catch (...) {
22757       {
22758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22759       };
22760     }
22761   }
22762
22763 }
22764
22765
22766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22767   void * jresult ;
22768   Dali::TypeRegistration *arg1 = 0 ;
22769   std::string *arg2 = 0 ;
22770   Dali::Property::Index arg3 ;
22771   Dali::Property::Type arg4 ;
22772   Dali::ChildPropertyRegistration *result = 0 ;
22773
22774   arg1 = (Dali::TypeRegistration *)jarg1;
22775   if (!arg1) {
22776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22777     return 0;
22778   }
22779   if (!jarg2) {
22780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22781     return 0;
22782   }
22783   std::string arg2_str(jarg2);
22784   arg2 = &arg2_str;
22785   arg3 = (Dali::Property::Index)jarg3;
22786   arg4 = (Dali::Property::Type)jarg4;
22787   {
22788     try {
22789       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22790     } catch (std::out_of_range& e) {
22791       {
22792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22793       };
22794     } catch (std::exception& e) {
22795       {
22796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22797       };
22798     } catch (Dali::DaliException e) {
22799       {
22800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22801       };
22802     } catch (...) {
22803       {
22804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22805       };
22806     }
22807   }
22808
22809   jresult = (void *)result;
22810
22811   //argout typemap for const std::string&
22812
22813   return jresult;
22814 }
22815
22816
22817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22818   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22819
22820   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22821   {
22822     try {
22823       delete arg1;
22824     } catch (std::out_of_range& e) {
22825       {
22826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22827       };
22828     } catch (std::exception& e) {
22829       {
22830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22831       };
22832     } catch (Dali::DaliException e) {
22833       {
22834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22835       };
22836     } catch (...) {
22837       {
22838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22839       };
22840     }
22841   }
22842
22843 }
22844
22845
22846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22847   unsigned int jresult ;
22848   std::string *arg1 = 0 ;
22849   std::type_info *arg2 = 0 ;
22850   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22851   bool result;
22852
22853   if (!jarg1) {
22854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22855     return 0;
22856   }
22857   std::string arg1_str(jarg1);
22858   arg1 = &arg1_str;
22859   arg2 = (std::type_info *)jarg2;
22860   if (!arg2) {
22861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22862     return 0;
22863   }
22864   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22865   {
22866     try {
22867       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22868     } catch (std::out_of_range& e) {
22869       {
22870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22871       };
22872     } catch (std::exception& e) {
22873       {
22874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22875       };
22876     } catch (Dali::DaliException e) {
22877       {
22878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22879       };
22880     } catch (...) {
22881       {
22882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22883       };
22884     }
22885   }
22886
22887   jresult = result;
22888
22889   //argout typemap for const std::string&
22890
22891   return jresult;
22892 }
22893
22894
22895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22896   unsigned int jresult ;
22897   std::string *arg1 = 0 ;
22898   std::string *arg2 = 0 ;
22899   Dali::Property::Index arg3 ;
22900   Dali::Property::Type arg4 ;
22901   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22902   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22903   bool result;
22904
22905   if (!jarg1) {
22906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22907     return 0;
22908   }
22909   std::string arg1_str(jarg1);
22910   arg1 = &arg1_str;
22911   if (!jarg2) {
22912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22913     return 0;
22914   }
22915   std::string arg2_str(jarg2);
22916   arg2 = &arg2_str;
22917   arg3 = (Dali::Property::Index)jarg3;
22918   arg4 = (Dali::Property::Type)jarg4;
22919   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22920   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22921   {
22922     try {
22923       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22924     } catch (std::out_of_range& e) {
22925       {
22926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22927       };
22928     } catch (std::exception& e) {
22929       {
22930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22931       };
22932     } catch (Dali::DaliException e) {
22933       {
22934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22935       };
22936     } catch (...) {
22937       {
22938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22939       };
22940     }
22941   }
22942
22943   jresult = result;
22944
22945   //argout typemap for const std::string&
22946
22947
22948   //argout typemap for const std::string&
22949
22950   return jresult;
22951 }
22952
22953
22954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22955   float jresult ;
22956   float result;
22957
22958   result = (float)(float)Dali::ParentOrigin::TOP;
22959   jresult = result;
22960   return jresult;
22961 }
22962
22963
22964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22965   float jresult ;
22966   float result;
22967
22968   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22969   jresult = result;
22970   return jresult;
22971 }
22972
22973
22974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22975   float jresult ;
22976   float result;
22977
22978   result = (float)(float)Dali::ParentOrigin::LEFT;
22979   jresult = result;
22980   return jresult;
22981 }
22982
22983
22984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22985   float jresult ;
22986   float result;
22987
22988   result = (float)(float)Dali::ParentOrigin::RIGHT;
22989   jresult = result;
22990   return jresult;
22991 }
22992
22993
22994 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22995   float jresult ;
22996   float result;
22997
22998   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22999   jresult = result;
23000   return jresult;
23001 }
23002
23003
23004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
23005   void * jresult ;
23006   Dali::Vector3 *result = 0 ;
23007
23008   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23009   jresult = (void *)result;
23010   return jresult;
23011 }
23012
23013
23014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23015   void * jresult ;
23016   Dali::Vector3 *result = 0 ;
23017
23018   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23019   jresult = (void *)result;
23020   return jresult;
23021 }
23022
23023
23024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23025   void * jresult ;
23026   Dali::Vector3 *result = 0 ;
23027
23028   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23029   jresult = (void *)result;
23030   return jresult;
23031 }
23032
23033
23034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23035   void * jresult ;
23036   Dali::Vector3 *result = 0 ;
23037
23038   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23039   jresult = (void *)result;
23040   return jresult;
23041 }
23042
23043
23044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23045   void * jresult ;
23046   Dali::Vector3 *result = 0 ;
23047
23048   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23049   jresult = (void *)result;
23050   return jresult;
23051 }
23052
23053
23054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23055   void * jresult ;
23056   Dali::Vector3 *result = 0 ;
23057
23058   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23059   jresult = (void *)result;
23060   return jresult;
23061 }
23062
23063
23064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23065   void * jresult ;
23066   Dali::Vector3 *result = 0 ;
23067
23068   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23069   jresult = (void *)result;
23070   return jresult;
23071 }
23072
23073
23074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23075   void * jresult ;
23076   Dali::Vector3 *result = 0 ;
23077
23078   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23079   jresult = (void *)result;
23080   return jresult;
23081 }
23082
23083
23084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23085   void * jresult ;
23086   Dali::Vector3 *result = 0 ;
23087
23088   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23089   jresult = (void *)result;
23090   return jresult;
23091 }
23092
23093
23094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23095   float jresult ;
23096   float result;
23097
23098   result = (float)(float)Dali::AnchorPoint::TOP;
23099   jresult = result;
23100   return jresult;
23101 }
23102
23103
23104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23105   float jresult ;
23106   float result;
23107
23108   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23109   jresult = result;
23110   return jresult;
23111 }
23112
23113
23114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23115   float jresult ;
23116   float result;
23117
23118   result = (float)(float)Dali::AnchorPoint::LEFT;
23119   jresult = result;
23120   return jresult;
23121 }
23122
23123
23124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23125   float jresult ;
23126   float result;
23127
23128   result = (float)(float)Dali::AnchorPoint::RIGHT;
23129   jresult = result;
23130   return jresult;
23131 }
23132
23133
23134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23135   float jresult ;
23136   float result;
23137
23138   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23139   jresult = result;
23140   return jresult;
23141 }
23142
23143
23144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23145   void * jresult ;
23146   Dali::Vector3 *result = 0 ;
23147
23148   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23149   jresult = (void *)result;
23150   return jresult;
23151 }
23152
23153
23154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23155   void * jresult ;
23156   Dali::Vector3 *result = 0 ;
23157
23158   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23159   jresult = (void *)result;
23160   return jresult;
23161 }
23162
23163
23164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23165   void * jresult ;
23166   Dali::Vector3 *result = 0 ;
23167
23168   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23169   jresult = (void *)result;
23170   return jresult;
23171 }
23172
23173
23174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23175   void * jresult ;
23176   Dali::Vector3 *result = 0 ;
23177
23178   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23179   jresult = (void *)result;
23180   return jresult;
23181 }
23182
23183
23184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23185   void * jresult ;
23186   Dali::Vector3 *result = 0 ;
23187
23188   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23189   jresult = (void *)result;
23190   return jresult;
23191 }
23192
23193
23194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23195   void * jresult ;
23196   Dali::Vector3 *result = 0 ;
23197
23198   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23199   jresult = (void *)result;
23200   return jresult;
23201 }
23202
23203
23204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23205   void * jresult ;
23206   Dali::Vector3 *result = 0 ;
23207
23208   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23209   jresult = (void *)result;
23210   return jresult;
23211 }
23212
23213
23214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23215   void * jresult ;
23216   Dali::Vector3 *result = 0 ;
23217
23218   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23219   jresult = (void *)result;
23220   return jresult;
23221 }
23222
23223
23224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23225   void * jresult ;
23226   Dali::Vector3 *result = 0 ;
23227
23228   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23229   jresult = (void *)result;
23230   return jresult;
23231 }
23232
23233
23234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23235   void * jresult ;
23236   Dali::Vector4 *result = 0 ;
23237
23238   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23239   jresult = (void *)result;
23240   return jresult;
23241 }
23242
23243
23244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23245   void * jresult ;
23246   Dali::Vector4 *result = 0 ;
23247
23248   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23249   jresult = (void *)result;
23250   return jresult;
23251 }
23252
23253
23254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23255   void * jresult ;
23256   Dali::Vector4 *result = 0 ;
23257
23258   result = (Dali::Vector4 *)&Dali::Color::RED;
23259   jresult = (void *)result;
23260   return jresult;
23261 }
23262
23263
23264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23265   void * jresult ;
23266   Dali::Vector4 *result = 0 ;
23267
23268   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23269   jresult = (void *)result;
23270   return jresult;
23271 }
23272
23273
23274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23275   void * jresult ;
23276   Dali::Vector4 *result = 0 ;
23277
23278   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23279   jresult = (void *)result;
23280   return jresult;
23281 }
23282
23283
23284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23285   void * jresult ;
23286   Dali::Vector4 *result = 0 ;
23287
23288   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23289   jresult = (void *)result;
23290   return jresult;
23291 }
23292
23293
23294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23295   void * jresult ;
23296   Dali::Vector4 *result = 0 ;
23297
23298   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23299   jresult = (void *)result;
23300   return jresult;
23301 }
23302
23303
23304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23305   void * jresult ;
23306   Dali::Vector4 *result = 0 ;
23307
23308   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23309   jresult = (void *)result;
23310   return jresult;
23311 }
23312
23313
23314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23315   void * jresult ;
23316   Dali::Vector4 *result = 0 ;
23317
23318   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23319   jresult = (void *)result;
23320   return jresult;
23321 }
23322
23323
23324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23325   float jresult ;
23326   float result;
23327
23328   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23329   jresult = result;
23330   return jresult;
23331 }
23332
23333
23334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23335   float jresult ;
23336   float result;
23337
23338   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23339   jresult = result;
23340   return jresult;
23341 }
23342
23343
23344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23345   float jresult ;
23346   float result;
23347
23348   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23349   jresult = result;
23350   return jresult;
23351 }
23352
23353
23354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23355   float jresult ;
23356   float result;
23357
23358   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23359   jresult = result;
23360   return jresult;
23361 }
23362
23363
23364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23365   float jresult ;
23366   float result;
23367
23368   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23369   jresult = result;
23370   return jresult;
23371 }
23372
23373
23374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23375   float jresult ;
23376   float result;
23377
23378   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23379   jresult = result;
23380   return jresult;
23381 }
23382
23383
23384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23385   float jresult ;
23386   float result;
23387
23388   result = (float)(float)Dali::Math::PI;
23389   jresult = result;
23390   return jresult;
23391 }
23392
23393
23394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23395   float jresult ;
23396   float result;
23397
23398   result = (float)(float)Dali::Math::PI_2;
23399   jresult = result;
23400   return jresult;
23401 }
23402
23403
23404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23405   float jresult ;
23406   float result;
23407
23408   result = (float)(float)Dali::Math::PI_4;
23409   jresult = result;
23410   return jresult;
23411 }
23412
23413
23414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23415   float jresult ;
23416   float result;
23417
23418   result = (float)(float)Dali::Math::PI_OVER_180;
23419   jresult = result;
23420   return jresult;
23421 }
23422
23423
23424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23425   float jresult ;
23426   float result;
23427
23428   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23429   jresult = result;
23430   return jresult;
23431 }
23432
23433
23434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23435   int jresult ;
23436   Dali::ResizePolicy::Type result;
23437
23438   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23439   jresult = (int)result;
23440   return jresult;
23441 }
23442
23443
23444 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23445   unsigned long jresult ;
23446   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23447   Dali::VectorBase::SizeType result;
23448
23449   arg1 = (Dali::VectorBase *)jarg1;
23450   {
23451     try {
23452       result = ((Dali::VectorBase const *)arg1)->Count();
23453     } catch (std::out_of_range& e) {
23454       {
23455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23456       };
23457     } catch (std::exception& e) {
23458       {
23459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23460       };
23461     } catch (Dali::DaliException e) {
23462       {
23463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23464       };
23465     } catch (...) {
23466       {
23467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23468       };
23469     }
23470   }
23471
23472   jresult = (unsigned long)result;
23473   return jresult;
23474 }
23475
23476
23477 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23478   unsigned long jresult ;
23479   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23480   Dali::VectorBase::SizeType result;
23481
23482   arg1 = (Dali::VectorBase *)jarg1;
23483   {
23484     try {
23485       result = ((Dali::VectorBase const *)arg1)->Size();
23486     } catch (std::out_of_range& e) {
23487       {
23488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23489       };
23490     } catch (std::exception& e) {
23491       {
23492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23493       };
23494     } catch (Dali::DaliException e) {
23495       {
23496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23497       };
23498     } catch (...) {
23499       {
23500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23501       };
23502     }
23503   }
23504
23505   jresult = (unsigned long)result;
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23511   unsigned int jresult ;
23512   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23513   bool result;
23514
23515   arg1 = (Dali::VectorBase *)jarg1;
23516   {
23517     try {
23518       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23519     } catch (std::out_of_range& e) {
23520       {
23521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23522       };
23523     } catch (std::exception& e) {
23524       {
23525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23526       };
23527     } catch (Dali::DaliException e) {
23528       {
23529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23530       };
23531     } catch (...) {
23532       {
23533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23534       };
23535     }
23536   }
23537
23538   jresult = result;
23539   return jresult;
23540 }
23541
23542
23543 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23544   unsigned long jresult ;
23545   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23546   Dali::VectorBase::SizeType result;
23547
23548   arg1 = (Dali::VectorBase *)jarg1;
23549   {
23550     try {
23551       result = ((Dali::VectorBase const *)arg1)->Capacity();
23552     } catch (std::out_of_range& e) {
23553       {
23554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23555       };
23556     } catch (std::exception& e) {
23557       {
23558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23559       };
23560     } catch (Dali::DaliException e) {
23561       {
23562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23563       };
23564     } catch (...) {
23565       {
23566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23567       };
23568     }
23569   }
23570
23571   jresult = (unsigned long)result;
23572   return jresult;
23573 }
23574
23575
23576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23577   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23578
23579   arg1 = (Dali::VectorBase *)jarg1;
23580   {
23581     try {
23582       (arg1)->Release();
23583     } catch (std::out_of_range& e) {
23584       {
23585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23586       };
23587     } catch (std::exception& e) {
23588       {
23589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23590       };
23591     } catch (Dali::DaliException e) {
23592       {
23593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23594       };
23595     } catch (...) {
23596       {
23597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23598       };
23599     }
23600   }
23601
23602 }
23603
23604
23605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23606   int jresult ;
23607   Dali::Pixel::Format result;
23608
23609   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23610   jresult = (int)result;
23611   return jresult;
23612 }
23613
23614
23615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23616   int jresult ;
23617   Dali::Pixel::Format result;
23618
23619   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23620   jresult = (int)result;
23621   return jresult;
23622 }
23623
23624
23625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23626   unsigned int jresult ;
23627   Dali::Pixel::Format arg1 ;
23628   bool result;
23629
23630   arg1 = (Dali::Pixel::Format)jarg1;
23631   {
23632     try {
23633       result = (bool)Dali::Pixel::HasAlpha(arg1);
23634     } catch (std::out_of_range& e) {
23635       {
23636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23637       };
23638     } catch (std::exception& e) {
23639       {
23640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23641       };
23642     } catch (Dali::DaliException e) {
23643       {
23644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23645       };
23646     } catch (...) {
23647       {
23648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23649       };
23650     }
23651   }
23652
23653   jresult = result;
23654   return jresult;
23655 }
23656
23657
23658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23659   unsigned int jresult ;
23660   Dali::Pixel::Format arg1 ;
23661   unsigned int result;
23662
23663   arg1 = (Dali::Pixel::Format)jarg1;
23664   {
23665     try {
23666       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23667     } catch (std::out_of_range& e) {
23668       {
23669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23670       };
23671     } catch (std::exception& e) {
23672       {
23673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23674       };
23675     } catch (Dali::DaliException e) {
23676       {
23677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23678       };
23679     } catch (...) {
23680       {
23681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23682       };
23683     }
23684   }
23685
23686   jresult = result;
23687   return jresult;
23688 }
23689
23690
23691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23692   Dali::Pixel::Format arg1 ;
23693   int *arg2 = 0 ;
23694   int *arg3 = 0 ;
23695
23696   arg1 = (Dali::Pixel::Format)jarg1;
23697   arg2 = (int *)jarg2;
23698   if (!arg2) {
23699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23700     return ;
23701   }
23702   arg3 = (int *)jarg3;
23703   if (!arg3) {
23704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23705     return ;
23706   }
23707   {
23708     try {
23709       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23710     } catch (std::out_of_range& e) {
23711       {
23712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23713       };
23714     } catch (std::exception& e) {
23715       {
23716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23717       };
23718     } catch (Dali::DaliException e) {
23719       {
23720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23721       };
23722     } catch (...) {
23723       {
23724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23725       };
23726     }
23727   }
23728
23729 }
23730
23731
23732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23733   void * jresult ;
23734   unsigned char *arg1 = (unsigned char *) 0 ;
23735   unsigned int arg2 ;
23736   unsigned int arg3 ;
23737   unsigned int arg4 ;
23738   Dali::Pixel::Format arg5 ;
23739   Dali::PixelData::ReleaseFunction arg6 ;
23740   Dali::PixelData result;
23741
23742   arg1 = jarg1;
23743   arg2 = (unsigned int)jarg2;
23744   arg3 = (unsigned int)jarg3;
23745   arg4 = (unsigned int)jarg4;
23746   arg5 = (Dali::Pixel::Format)jarg5;
23747   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23748   {
23749     try {
23750       auto pixelBuffer = new unsigned char[jarg2];
23751       memcpy( pixelBuffer, arg1, arg2);
23752       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23753     } catch (std::out_of_range& e) {
23754       {
23755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23756       };
23757     } catch (std::exception& e) {
23758       {
23759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23760       };
23761     } catch (Dali::DaliException e) {
23762       {
23763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23764       };
23765     } catch (...) {
23766       {
23767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23768       };
23769     }
23770   }
23771
23772   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23773
23774
23775   return jresult;
23776 }
23777
23778
23779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23780   void * jresult ;
23781   Dali::PixelData *result = 0 ;
23782
23783   {
23784     try {
23785       result = (Dali::PixelData *)new Dali::PixelData();
23786     } catch (std::out_of_range& e) {
23787       {
23788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23789       };
23790     } catch (std::exception& e) {
23791       {
23792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23793       };
23794     } catch (Dali::DaliException e) {
23795       {
23796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23797       };
23798     } catch (...) {
23799       {
23800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23801       };
23802     }
23803   }
23804
23805   jresult = (void *)result;
23806   return jresult;
23807 }
23808
23809
23810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23811   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23812
23813   arg1 = (Dali::PixelData *)jarg1;
23814   {
23815     try {
23816       delete arg1;
23817     } catch (std::out_of_range& e) {
23818       {
23819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23820       };
23821     } catch (std::exception& e) {
23822       {
23823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23824       };
23825     } catch (Dali::DaliException e) {
23826       {
23827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23828       };
23829     } catch (...) {
23830       {
23831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23832       };
23833     }
23834   }
23835
23836 }
23837
23838
23839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23840   void * jresult ;
23841   Dali::PixelData *arg1 = 0 ;
23842   Dali::PixelData *result = 0 ;
23843
23844   arg1 = (Dali::PixelData *)jarg1;
23845   if (!arg1) {
23846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23847     return 0;
23848   }
23849   {
23850     try {
23851       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23852     } catch (std::out_of_range& e) {
23853       {
23854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23855       };
23856     } catch (std::exception& e) {
23857       {
23858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23859       };
23860     } catch (Dali::DaliException e) {
23861       {
23862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23863       };
23864     } catch (...) {
23865       {
23866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23867       };
23868     }
23869   }
23870
23871   jresult = (void *)result;
23872   return jresult;
23873 }
23874
23875
23876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23877   void * jresult ;
23878   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23879   Dali::PixelData *arg2 = 0 ;
23880   Dali::PixelData *result = 0 ;
23881
23882   arg1 = (Dali::PixelData *)jarg1;
23883   arg2 = (Dali::PixelData *)jarg2;
23884   if (!arg2) {
23885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23886     return 0;
23887   }
23888   {
23889     try {
23890       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23891     } catch (std::out_of_range& e) {
23892       {
23893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23894       };
23895     } catch (std::exception& e) {
23896       {
23897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23898       };
23899     } catch (Dali::DaliException e) {
23900       {
23901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23902       };
23903     } catch (...) {
23904       {
23905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23906       };
23907     }
23908   }
23909
23910   jresult = (void *)result;
23911   return jresult;
23912 }
23913
23914
23915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23916   unsigned int jresult ;
23917   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23918   unsigned int result;
23919
23920   arg1 = (Dali::PixelData *)jarg1;
23921   {
23922     try {
23923       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23924     } catch (std::out_of_range& e) {
23925       {
23926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23927       };
23928     } catch (std::exception& e) {
23929       {
23930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23931       };
23932     } catch (Dali::DaliException e) {
23933       {
23934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23935       };
23936     } catch (...) {
23937       {
23938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23939       };
23940     }
23941   }
23942
23943   jresult = result;
23944   return jresult;
23945 }
23946
23947
23948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23949   unsigned int jresult ;
23950   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23951   unsigned int result;
23952
23953   arg1 = (Dali::PixelData *)jarg1;
23954   {
23955     try {
23956       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23957     } catch (std::out_of_range& e) {
23958       {
23959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23960       };
23961     } catch (std::exception& e) {
23962       {
23963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23964       };
23965     } catch (Dali::DaliException e) {
23966       {
23967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23968       };
23969     } catch (...) {
23970       {
23971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23972       };
23973     }
23974   }
23975
23976   jresult = result;
23977   return jresult;
23978 }
23979
23980
23981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23982   int jresult ;
23983   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23984   Dali::Pixel::Format result;
23985
23986   arg1 = (Dali::PixelData *)jarg1;
23987   {
23988     try {
23989       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23990     } catch (std::out_of_range& e) {
23991       {
23992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23993       };
23994     } catch (std::exception& e) {
23995       {
23996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23997       };
23998     } catch (Dali::DaliException e) {
23999       {
24000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24001       };
24002     } catch (...) {
24003       {
24004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24005       };
24006     }
24007   }
24008
24009   jresult = (int)result;
24010   return jresult;
24011 }
24012
24013
24014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24015   unsigned int jresult ;
24016   unsigned int result;
24017
24018   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24019   jresult = result;
24020   return jresult;
24021 }
24022
24023
24024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24025   unsigned int jresult ;
24026   unsigned int result;
24027
24028   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24029   jresult = result;
24030   return jresult;
24031 }
24032
24033
24034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24035   unsigned int jresult ;
24036   unsigned int result;
24037
24038   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24039   jresult = result;
24040   return jresult;
24041 }
24042
24043
24044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24045   unsigned int jresult ;
24046   unsigned int result;
24047
24048   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24049   jresult = result;
24050   return jresult;
24051 }
24052
24053
24054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24055   unsigned int jresult ;
24056   unsigned int result;
24057
24058   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24059   jresult = result;
24060   return jresult;
24061 }
24062
24063
24064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24065   unsigned int jresult ;
24066   unsigned int result;
24067
24068   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24069   jresult = result;
24070   return jresult;
24071 }
24072
24073
24074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24075   void * jresult ;
24076   Dali::TextureType::Type arg1 ;
24077   Dali::Pixel::Format arg2 ;
24078   unsigned int arg3 ;
24079   unsigned int arg4 ;
24080   Dali::Texture result;
24081
24082   arg1 = (Dali::TextureType::Type)jarg1;
24083   arg2 = (Dali::Pixel::Format)jarg2;
24084   arg3 = (unsigned int)jarg3;
24085   arg4 = (unsigned int)jarg4;
24086   {
24087     try {
24088       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24089     } catch (std::out_of_range& e) {
24090       {
24091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24092       };
24093     } catch (std::exception& e) {
24094       {
24095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24096       };
24097     } catch (Dali::DaliException e) {
24098       {
24099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24100       };
24101     } catch (...) {
24102       {
24103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24104       };
24105     }
24106   }
24107
24108   jresult = new Dali::Texture((const Dali::Texture &)result);
24109   return jresult;
24110 }
24111
24112
24113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24114   void * jresult ;
24115   NativeImageInterface *arg1 = 0 ;
24116   Dali::Texture result;
24117
24118   arg1 = (NativeImageInterface *)jarg1;
24119   if (!arg1) {
24120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24121     return 0;
24122   }
24123   {
24124     try {
24125       result = Dali::Texture::New(*arg1);
24126     } catch (std::out_of_range& e) {
24127       {
24128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24129       };
24130     } catch (std::exception& e) {
24131       {
24132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24133       };
24134     } catch (Dali::DaliException e) {
24135       {
24136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24137       };
24138     } catch (...) {
24139       {
24140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24141       };
24142     }
24143   }
24144
24145   jresult = new Dali::Texture((const Dali::Texture &)result);
24146   return jresult;
24147 }
24148
24149
24150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24151   void * jresult ;
24152   Dali::Texture *result = 0 ;
24153
24154   {
24155     try {
24156       result = (Dali::Texture *)new Dali::Texture();
24157     } catch (std::out_of_range& e) {
24158       {
24159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24160       };
24161     } catch (std::exception& e) {
24162       {
24163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24164       };
24165     } catch (Dali::DaliException e) {
24166       {
24167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24168       };
24169     } catch (...) {
24170       {
24171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24172       };
24173     }
24174   }
24175
24176   jresult = (void *)result;
24177   return jresult;
24178 }
24179
24180
24181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24182   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24183
24184   arg1 = (Dali::Texture *)jarg1;
24185   {
24186     try {
24187       delete arg1;
24188     } catch (std::out_of_range& e) {
24189       {
24190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24191       };
24192     } catch (std::exception& e) {
24193       {
24194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24195       };
24196     } catch (Dali::DaliException e) {
24197       {
24198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24199       };
24200     } catch (...) {
24201       {
24202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24203       };
24204     }
24205   }
24206
24207 }
24208
24209
24210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24211   void * jresult ;
24212   Dali::Texture *arg1 = 0 ;
24213   Dali::Texture *result = 0 ;
24214
24215   arg1 = (Dali::Texture *)jarg1;
24216   if (!arg1) {
24217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24218     return 0;
24219   }
24220   {
24221     try {
24222       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24223     } catch (std::out_of_range& e) {
24224       {
24225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24226       };
24227     } catch (std::exception& e) {
24228       {
24229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24230       };
24231     } catch (Dali::DaliException e) {
24232       {
24233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24234       };
24235     } catch (...) {
24236       {
24237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24238       };
24239     }
24240   }
24241
24242   jresult = (void *)result;
24243   return jresult;
24244 }
24245
24246
24247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24248   void * jresult ;
24249   Dali::BaseHandle arg1 ;
24250   Dali::BaseHandle *argp1 ;
24251   Dali::Texture result;
24252
24253   argp1 = (Dali::BaseHandle *)jarg1;
24254   if (!argp1) {
24255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24256     return 0;
24257   }
24258   arg1 = *argp1;
24259   {
24260     try {
24261       result = Dali::Texture::DownCast(arg1);
24262     } catch (std::out_of_range& e) {
24263       {
24264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24265       };
24266     } catch (std::exception& e) {
24267       {
24268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24269       };
24270     } catch (Dali::DaliException e) {
24271       {
24272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24273       };
24274     } catch (...) {
24275       {
24276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24277       };
24278     }
24279   }
24280
24281   jresult = new Dali::Texture((const Dali::Texture &)result);
24282   return jresult;
24283 }
24284
24285
24286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24287   void * jresult ;
24288   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24289   Dali::Texture *arg2 = 0 ;
24290   Dali::Texture *result = 0 ;
24291
24292   arg1 = (Dali::Texture *)jarg1;
24293   arg2 = (Dali::Texture *)jarg2;
24294   if (!arg2) {
24295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24296     return 0;
24297   }
24298   {
24299     try {
24300       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24301     } catch (std::out_of_range& e) {
24302       {
24303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24304       };
24305     } catch (std::exception& e) {
24306       {
24307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24308       };
24309     } catch (Dali::DaliException e) {
24310       {
24311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24312       };
24313     } catch (...) {
24314       {
24315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24316       };
24317     }
24318   }
24319
24320   jresult = (void *)result;
24321   return jresult;
24322 }
24323
24324
24325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24326   unsigned int jresult ;
24327   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24328   Dali::PixelData arg2 ;
24329   Dali::PixelData *argp2 ;
24330   bool result;
24331
24332   arg1 = (Dali::Texture *)jarg1;
24333   argp2 = (Dali::PixelData *)jarg2;
24334   if (!argp2) {
24335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24336     return 0;
24337   }
24338   arg2 = *argp2;
24339   {
24340     try {
24341       result = (bool)(arg1)->Upload(arg2);
24342     } catch (std::out_of_range& e) {
24343       {
24344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24345       };
24346     } catch (std::exception& e) {
24347       {
24348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24349       };
24350     } catch (Dali::DaliException e) {
24351       {
24352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24353       };
24354     } catch (...) {
24355       {
24356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24357       };
24358     }
24359   }
24360
24361   jresult = result;
24362   return jresult;
24363 }
24364
24365
24366 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) {
24367   unsigned int jresult ;
24368   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24369   Dali::PixelData arg2 ;
24370   unsigned int arg3 ;
24371   unsigned int arg4 ;
24372   unsigned int arg5 ;
24373   unsigned int arg6 ;
24374   unsigned int arg7 ;
24375   unsigned int arg8 ;
24376   Dali::PixelData *argp2 ;
24377   bool result;
24378
24379   arg1 = (Dali::Texture *)jarg1;
24380   argp2 = (Dali::PixelData *)jarg2;
24381   if (!argp2) {
24382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24383     return 0;
24384   }
24385   arg2 = *argp2;
24386   arg3 = (unsigned int)jarg3;
24387   arg4 = (unsigned int)jarg4;
24388   arg5 = (unsigned int)jarg5;
24389   arg6 = (unsigned int)jarg6;
24390   arg7 = (unsigned int)jarg7;
24391   arg8 = (unsigned int)jarg8;
24392   {
24393     try {
24394       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24395     } catch (std::out_of_range& e) {
24396       {
24397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24398       };
24399     } catch (std::exception& e) {
24400       {
24401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24402       };
24403     } catch (Dali::DaliException e) {
24404       {
24405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24406       };
24407     } catch (...) {
24408       {
24409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24410       };
24411     }
24412   }
24413
24414   jresult = result;
24415   return jresult;
24416 }
24417
24418
24419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24420   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24421
24422   arg1 = (Dali::Texture *)jarg1;
24423   {
24424     try {
24425       (arg1)->GenerateMipmaps();
24426     } catch (std::out_of_range& e) {
24427       {
24428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24429       };
24430     } catch (std::exception& e) {
24431       {
24432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24433       };
24434     } catch (Dali::DaliException e) {
24435       {
24436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24437       };
24438     } catch (...) {
24439       {
24440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24441       };
24442     }
24443   }
24444
24445 }
24446
24447
24448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24449   unsigned int jresult ;
24450   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24451   unsigned int result;
24452
24453   arg1 = (Dali::Texture *)jarg1;
24454   {
24455     try {
24456       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24457     } catch (std::out_of_range& e) {
24458       {
24459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24460       };
24461     } catch (std::exception& e) {
24462       {
24463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24464       };
24465     } catch (Dali::DaliException e) {
24466       {
24467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24468       };
24469     } catch (...) {
24470       {
24471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24472       };
24473     }
24474   }
24475
24476   jresult = result;
24477   return jresult;
24478 }
24479
24480
24481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24482   unsigned int jresult ;
24483   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24484   unsigned int result;
24485
24486   arg1 = (Dali::Texture *)jarg1;
24487   {
24488     try {
24489       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24490     } catch (std::out_of_range& e) {
24491       {
24492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24493       };
24494     } catch (std::exception& e) {
24495       {
24496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24497       };
24498     } catch (Dali::DaliException e) {
24499       {
24500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24501       };
24502     } catch (...) {
24503       {
24504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24505       };
24506     }
24507   }
24508
24509   jresult = result;
24510   return jresult;
24511 }
24512
24513
24514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24515   void * jresult ;
24516   Dali::Sampler result;
24517
24518   {
24519     try {
24520       result = Dali::Sampler::New();
24521     } catch (std::out_of_range& e) {
24522       {
24523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24524       };
24525     } catch (std::exception& e) {
24526       {
24527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24528       };
24529     } catch (Dali::DaliException e) {
24530       {
24531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24532       };
24533     } catch (...) {
24534       {
24535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24536       };
24537     }
24538   }
24539
24540   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24541   return jresult;
24542 }
24543
24544
24545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24546   void * jresult ;
24547   Dali::Sampler *result = 0 ;
24548
24549   {
24550     try {
24551       result = (Dali::Sampler *)new Dali::Sampler();
24552     } catch (std::out_of_range& e) {
24553       {
24554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24555       };
24556     } catch (std::exception& e) {
24557       {
24558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24559       };
24560     } catch (Dali::DaliException e) {
24561       {
24562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24563       };
24564     } catch (...) {
24565       {
24566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24567       };
24568     }
24569   }
24570
24571   jresult = (void *)result;
24572   return jresult;
24573 }
24574
24575
24576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24577   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24578
24579   arg1 = (Dali::Sampler *)jarg1;
24580   {
24581     try {
24582       delete arg1;
24583     } catch (std::out_of_range& e) {
24584       {
24585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24586       };
24587     } catch (std::exception& e) {
24588       {
24589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24590       };
24591     } catch (Dali::DaliException e) {
24592       {
24593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24594       };
24595     } catch (...) {
24596       {
24597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24598       };
24599     }
24600   }
24601
24602 }
24603
24604
24605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24606   void * jresult ;
24607   Dali::Sampler *arg1 = 0 ;
24608   Dali::Sampler *result = 0 ;
24609
24610   arg1 = (Dali::Sampler *)jarg1;
24611   if (!arg1) {
24612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24613     return 0;
24614   }
24615   {
24616     try {
24617       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24618     } catch (std::out_of_range& e) {
24619       {
24620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24621       };
24622     } catch (std::exception& e) {
24623       {
24624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24625       };
24626     } catch (Dali::DaliException e) {
24627       {
24628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24629       };
24630     } catch (...) {
24631       {
24632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24633       };
24634     }
24635   }
24636
24637   jresult = (void *)result;
24638   return jresult;
24639 }
24640
24641
24642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24643   void * jresult ;
24644   Dali::BaseHandle arg1 ;
24645   Dali::BaseHandle *argp1 ;
24646   Dali::Sampler result;
24647
24648   argp1 = (Dali::BaseHandle *)jarg1;
24649   if (!argp1) {
24650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24651     return 0;
24652   }
24653   arg1 = *argp1;
24654   {
24655     try {
24656       result = Dali::Sampler::DownCast(arg1);
24657     } catch (std::out_of_range& e) {
24658       {
24659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24660       };
24661     } catch (std::exception& e) {
24662       {
24663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24664       };
24665     } catch (Dali::DaliException e) {
24666       {
24667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24668       };
24669     } catch (...) {
24670       {
24671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24672       };
24673     }
24674   }
24675
24676   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24677   return jresult;
24678 }
24679
24680
24681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24682   void * jresult ;
24683   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24684   Dali::Sampler *arg2 = 0 ;
24685   Dali::Sampler *result = 0 ;
24686
24687   arg1 = (Dali::Sampler *)jarg1;
24688   arg2 = (Dali::Sampler *)jarg2;
24689   if (!arg2) {
24690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24691     return 0;
24692   }
24693   {
24694     try {
24695       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24696     } catch (std::out_of_range& e) {
24697       {
24698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24699       };
24700     } catch (std::exception& e) {
24701       {
24702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24703       };
24704     } catch (Dali::DaliException e) {
24705       {
24706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24707       };
24708     } catch (...) {
24709       {
24710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24711       };
24712     }
24713   }
24714
24715   jresult = (void *)result;
24716   return jresult;
24717 }
24718
24719
24720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24721   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24722   Dali::FilterMode::Type arg2 ;
24723   Dali::FilterMode::Type arg3 ;
24724
24725   arg1 = (Dali::Sampler *)jarg1;
24726   arg2 = (Dali::FilterMode::Type)jarg2;
24727   arg3 = (Dali::FilterMode::Type)jarg3;
24728   {
24729     try {
24730       (arg1)->SetFilterMode(arg2,arg3);
24731     } catch (std::out_of_range& e) {
24732       {
24733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24734       };
24735     } catch (std::exception& e) {
24736       {
24737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24738       };
24739     } catch (Dali::DaliException e) {
24740       {
24741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24742       };
24743     } catch (...) {
24744       {
24745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24746       };
24747     }
24748   }
24749
24750 }
24751
24752
24753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24754   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24755   Dali::WrapMode::Type arg2 ;
24756   Dali::WrapMode::Type arg3 ;
24757
24758   arg1 = (Dali::Sampler *)jarg1;
24759   arg2 = (Dali::WrapMode::Type)jarg2;
24760   arg3 = (Dali::WrapMode::Type)jarg3;
24761   {
24762     try {
24763       (arg1)->SetWrapMode(arg2,arg3);
24764     } catch (std::out_of_range& e) {
24765       {
24766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24767       };
24768     } catch (std::exception& e) {
24769       {
24770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24771       };
24772     } catch (Dali::DaliException e) {
24773       {
24774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24775       };
24776     } catch (...) {
24777       {
24778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24779       };
24780     }
24781   }
24782
24783 }
24784
24785
24786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24787   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24788   Dali::WrapMode::Type arg2 ;
24789   Dali::WrapMode::Type arg3 ;
24790   Dali::WrapMode::Type arg4 ;
24791
24792   arg1 = (Dali::Sampler *)jarg1;
24793   arg2 = (Dali::WrapMode::Type)jarg2;
24794   arg3 = (Dali::WrapMode::Type)jarg3;
24795   arg4 = (Dali::WrapMode::Type)jarg4;
24796   {
24797     try {
24798       (arg1)->SetWrapMode(arg2,arg3,arg4);
24799     } catch (std::out_of_range& e) {
24800       {
24801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24802       };
24803     } catch (std::exception& e) {
24804       {
24805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24806       };
24807     } catch (Dali::DaliException e) {
24808       {
24809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24810       };
24811     } catch (...) {
24812       {
24813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24814       };
24815     }
24816   }
24817
24818 }
24819
24820
24821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24822   void * jresult ;
24823   Dali::TextureSet result;
24824
24825   {
24826     try {
24827       result = Dali::TextureSet::New();
24828     } catch (std::out_of_range& e) {
24829       {
24830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24831       };
24832     } catch (std::exception& e) {
24833       {
24834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24835       };
24836     } catch (Dali::DaliException e) {
24837       {
24838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24839       };
24840     } catch (...) {
24841       {
24842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24843       };
24844     }
24845   }
24846
24847   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24848   return jresult;
24849 }
24850
24851
24852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24853   void * jresult ;
24854   Dali::TextureSet *result = 0 ;
24855
24856   {
24857     try {
24858       result = (Dali::TextureSet *)new Dali::TextureSet();
24859     } catch (std::out_of_range& e) {
24860       {
24861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24862       };
24863     } catch (std::exception& e) {
24864       {
24865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24866       };
24867     } catch (Dali::DaliException e) {
24868       {
24869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24870       };
24871     } catch (...) {
24872       {
24873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24874       };
24875     }
24876   }
24877
24878   jresult = (void *)result;
24879   return jresult;
24880 }
24881
24882
24883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24884   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24885
24886   arg1 = (Dali::TextureSet *)jarg1;
24887   {
24888     try {
24889       delete arg1;
24890     } catch (std::out_of_range& e) {
24891       {
24892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24893       };
24894     } catch (std::exception& e) {
24895       {
24896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24897       };
24898     } catch (Dali::DaliException e) {
24899       {
24900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24901       };
24902     } catch (...) {
24903       {
24904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24905       };
24906     }
24907   }
24908
24909 }
24910
24911
24912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24913   void * jresult ;
24914   Dali::TextureSet *arg1 = 0 ;
24915   Dali::TextureSet *result = 0 ;
24916
24917   arg1 = (Dali::TextureSet *)jarg1;
24918   if (!arg1) {
24919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24920     return 0;
24921   }
24922   {
24923     try {
24924       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24925     } catch (std::out_of_range& e) {
24926       {
24927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24928       };
24929     } catch (std::exception& e) {
24930       {
24931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24932       };
24933     } catch (Dali::DaliException e) {
24934       {
24935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24936       };
24937     } catch (...) {
24938       {
24939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24940       };
24941     }
24942   }
24943
24944   jresult = (void *)result;
24945   return jresult;
24946 }
24947
24948
24949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24950   void * jresult ;
24951   Dali::BaseHandle arg1 ;
24952   Dali::BaseHandle *argp1 ;
24953   Dali::TextureSet result;
24954
24955   argp1 = (Dali::BaseHandle *)jarg1;
24956   if (!argp1) {
24957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24958     return 0;
24959   }
24960   arg1 = *argp1;
24961   {
24962     try {
24963       result = Dali::TextureSet::DownCast(arg1);
24964     } catch (std::out_of_range& e) {
24965       {
24966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24967       };
24968     } catch (std::exception& e) {
24969       {
24970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24971       };
24972     } catch (Dali::DaliException e) {
24973       {
24974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24975       };
24976     } catch (...) {
24977       {
24978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24979       };
24980     }
24981   }
24982
24983   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24984   return jresult;
24985 }
24986
24987
24988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24989   void * jresult ;
24990   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24991   Dali::TextureSet *arg2 = 0 ;
24992   Dali::TextureSet *result = 0 ;
24993
24994   arg1 = (Dali::TextureSet *)jarg1;
24995   arg2 = (Dali::TextureSet *)jarg2;
24996   if (!arg2) {
24997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24998     return 0;
24999   }
25000   {
25001     try {
25002       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25003     } catch (std::out_of_range& e) {
25004       {
25005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25006       };
25007     } catch (std::exception& e) {
25008       {
25009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25010       };
25011     } catch (Dali::DaliException e) {
25012       {
25013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25014       };
25015     } catch (...) {
25016       {
25017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25018       };
25019     }
25020   }
25021
25022   jresult = (void *)result;
25023   return jresult;
25024 }
25025
25026
25027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25028   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25029   size_t arg2 ;
25030   Dali::Texture arg3 ;
25031   Dali::Texture *argp3 ;
25032
25033   arg1 = (Dali::TextureSet *)jarg1;
25034   arg2 = (size_t)jarg2;
25035   argp3 = (Dali::Texture *)jarg3;
25036   if (!argp3) {
25037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25038     return ;
25039   }
25040   arg3 = *argp3;
25041   {
25042     try {
25043       (arg1)->SetTexture(arg2,arg3);
25044     } catch (std::out_of_range& e) {
25045       {
25046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25047       };
25048     } catch (std::exception& e) {
25049       {
25050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25051       };
25052     } catch (Dali::DaliException e) {
25053       {
25054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25055       };
25056     } catch (...) {
25057       {
25058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25059       };
25060     }
25061   }
25062
25063 }
25064
25065
25066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25067   void * jresult ;
25068   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25069   size_t arg2 ;
25070   Dali::Texture result;
25071
25072   arg1 = (Dali::TextureSet *)jarg1;
25073   arg2 = (size_t)jarg2;
25074   {
25075     try {
25076       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25077     } catch (std::out_of_range& e) {
25078       {
25079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25080       };
25081     } catch (std::exception& e) {
25082       {
25083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25084       };
25085     } catch (Dali::DaliException e) {
25086       {
25087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25088       };
25089     } catch (...) {
25090       {
25091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25092       };
25093     }
25094   }
25095
25096   jresult = new Dali::Texture((const Dali::Texture &)result);
25097   return jresult;
25098 }
25099
25100
25101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25102   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25103   size_t arg2 ;
25104   Dali::Sampler arg3 ;
25105   Dali::Sampler *argp3 ;
25106
25107   arg1 = (Dali::TextureSet *)jarg1;
25108   arg2 = (size_t)jarg2;
25109   argp3 = (Dali::Sampler *)jarg3;
25110   if (!argp3) {
25111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25112     return ;
25113   }
25114   arg3 = *argp3;
25115   {
25116     try {
25117       (arg1)->SetSampler(arg2,arg3);
25118     } catch (std::out_of_range& e) {
25119       {
25120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25121       };
25122     } catch (std::exception& e) {
25123       {
25124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25125       };
25126     } catch (Dali::DaliException e) {
25127       {
25128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25129       };
25130     } catch (...) {
25131       {
25132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25133       };
25134     }
25135   }
25136
25137 }
25138
25139
25140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25141   void * jresult ;
25142   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25143   size_t arg2 ;
25144   Dali::Sampler result;
25145
25146   arg1 = (Dali::TextureSet *)jarg1;
25147   arg2 = (size_t)jarg2;
25148   {
25149     try {
25150       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25151     } catch (std::out_of_range& e) {
25152       {
25153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25154       };
25155     } catch (std::exception& e) {
25156       {
25157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25158       };
25159     } catch (Dali::DaliException e) {
25160       {
25161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25162       };
25163     } catch (...) {
25164       {
25165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25166       };
25167     }
25168   }
25169
25170   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25171   return jresult;
25172 }
25173
25174
25175 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25176   unsigned long jresult ;
25177   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25178   size_t result;
25179
25180   arg1 = (Dali::TextureSet *)jarg1;
25181   {
25182     try {
25183       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25184     } catch (std::out_of_range& e) {
25185       {
25186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25187       };
25188     } catch (std::exception& e) {
25189       {
25190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25191       };
25192     } catch (Dali::DaliException e) {
25193       {
25194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25195       };
25196     } catch (...) {
25197       {
25198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25199       };
25200     }
25201   }
25202
25203   jresult = (unsigned long)result;
25204   return jresult;
25205 }
25206
25207
25208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25209   void * jresult ;
25210   Dali::Property::Map *arg1 = 0 ;
25211   Dali::PropertyBuffer result;
25212
25213   arg1 = (Dali::Property::Map *)jarg1;
25214   if (!arg1) {
25215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25216     return 0;
25217   }
25218   {
25219     try {
25220       result = Dali::PropertyBuffer::New(*arg1);
25221     } catch (std::out_of_range& e) {
25222       {
25223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25224       };
25225     } catch (std::exception& e) {
25226       {
25227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25228       };
25229     } catch (Dali::DaliException e) {
25230       {
25231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25232       };
25233     } catch (...) {
25234       {
25235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25236       };
25237     }
25238   }
25239
25240   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25241   return jresult;
25242 }
25243
25244
25245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25246   void * jresult ;
25247   Dali::PropertyBuffer *result = 0 ;
25248
25249   {
25250     try {
25251       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25252     } catch (std::out_of_range& e) {
25253       {
25254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25255       };
25256     } catch (std::exception& e) {
25257       {
25258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25259       };
25260     } catch (Dali::DaliException e) {
25261       {
25262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25263       };
25264     } catch (...) {
25265       {
25266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25267       };
25268     }
25269   }
25270
25271   jresult = (void *)result;
25272   return jresult;
25273 }
25274
25275
25276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25277   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25278
25279   arg1 = (Dali::PropertyBuffer *)jarg1;
25280   {
25281     try {
25282       delete arg1;
25283     } catch (std::out_of_range& e) {
25284       {
25285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25286       };
25287     } catch (std::exception& e) {
25288       {
25289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25290       };
25291     } catch (Dali::DaliException e) {
25292       {
25293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25294       };
25295     } catch (...) {
25296       {
25297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25298       };
25299     }
25300   }
25301
25302 }
25303
25304
25305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25306   void * jresult ;
25307   Dali::PropertyBuffer *arg1 = 0 ;
25308   Dali::PropertyBuffer *result = 0 ;
25309
25310   arg1 = (Dali::PropertyBuffer *)jarg1;
25311   if (!arg1) {
25312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25313     return 0;
25314   }
25315   {
25316     try {
25317       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25318     } catch (std::out_of_range& e) {
25319       {
25320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25321       };
25322     } catch (std::exception& e) {
25323       {
25324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25325       };
25326     } catch (Dali::DaliException e) {
25327       {
25328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25329       };
25330     } catch (...) {
25331       {
25332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25333       };
25334     }
25335   }
25336
25337   jresult = (void *)result;
25338   return jresult;
25339 }
25340
25341
25342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25343   void * jresult ;
25344   Dali::BaseHandle arg1 ;
25345   Dali::BaseHandle *argp1 ;
25346   Dali::PropertyBuffer result;
25347
25348   argp1 = (Dali::BaseHandle *)jarg1;
25349   if (!argp1) {
25350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25351     return 0;
25352   }
25353   arg1 = *argp1;
25354   {
25355     try {
25356       result = Dali::PropertyBuffer::DownCast(arg1);
25357     } catch (std::out_of_range& e) {
25358       {
25359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25360       };
25361     } catch (std::exception& e) {
25362       {
25363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25364       };
25365     } catch (Dali::DaliException e) {
25366       {
25367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25368       };
25369     } catch (...) {
25370       {
25371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25372       };
25373     }
25374   }
25375
25376   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25377   return jresult;
25378 }
25379
25380
25381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25382   void * jresult ;
25383   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25384   Dali::PropertyBuffer *arg2 = 0 ;
25385   Dali::PropertyBuffer *result = 0 ;
25386
25387   arg1 = (Dali::PropertyBuffer *)jarg1;
25388   arg2 = (Dali::PropertyBuffer *)jarg2;
25389   if (!arg2) {
25390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25391     return 0;
25392   }
25393   {
25394     try {
25395       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25396     } catch (std::out_of_range& e) {
25397       {
25398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25399       };
25400     } catch (std::exception& e) {
25401       {
25402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25403       };
25404     } catch (Dali::DaliException e) {
25405       {
25406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25407       };
25408     } catch (...) {
25409       {
25410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25411       };
25412     }
25413   }
25414
25415   jresult = (void *)result;
25416   return jresult;
25417 }
25418
25419
25420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25421   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25422   void *arg2 = (void *) 0 ;
25423   std::size_t arg3 ;
25424
25425   arg1 = (Dali::PropertyBuffer *)jarg1;
25426   arg2 = jarg2;
25427   arg3 = (std::size_t)jarg3;
25428   {
25429     try {
25430       (arg1)->SetData((void const *)arg2,arg3);
25431     } catch (std::out_of_range& e) {
25432       {
25433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25434       };
25435     } catch (std::exception& e) {
25436       {
25437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25438       };
25439     } catch (Dali::DaliException e) {
25440       {
25441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25442       };
25443     } catch (...) {
25444       {
25445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25446       };
25447     }
25448   }
25449
25450 }
25451
25452
25453 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25454   unsigned long jresult ;
25455   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25456   std::size_t result;
25457
25458   arg1 = (Dali::PropertyBuffer *)jarg1;
25459   {
25460     try {
25461       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25462     } catch (std::out_of_range& e) {
25463       {
25464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25465       };
25466     } catch (std::exception& e) {
25467       {
25468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25469       };
25470     } catch (Dali::DaliException e) {
25471       {
25472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25473       };
25474     } catch (...) {
25475       {
25476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25477       };
25478     }
25479   }
25480
25481   jresult = (unsigned long)result;
25482   return jresult;
25483 }
25484
25485
25486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25487   void * jresult ;
25488   Dali::Geometry result;
25489
25490   {
25491     try {
25492       result = Dali::Geometry::New();
25493     } catch (std::out_of_range& e) {
25494       {
25495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25496       };
25497     } catch (std::exception& e) {
25498       {
25499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25500       };
25501     } catch (Dali::DaliException e) {
25502       {
25503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25504       };
25505     } catch (...) {
25506       {
25507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25508       };
25509     }
25510   }
25511
25512   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25513   return jresult;
25514 }
25515
25516
25517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25518   void * jresult ;
25519   Dali::Geometry *result = 0 ;
25520
25521   {
25522     try {
25523       result = (Dali::Geometry *)new Dali::Geometry();
25524     } catch (std::out_of_range& e) {
25525       {
25526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25527       };
25528     } catch (std::exception& e) {
25529       {
25530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25531       };
25532     } catch (Dali::DaliException e) {
25533       {
25534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25535       };
25536     } catch (...) {
25537       {
25538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25539       };
25540     }
25541   }
25542
25543   jresult = (void *)result;
25544   return jresult;
25545 }
25546
25547
25548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25549   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25550
25551   arg1 = (Dali::Geometry *)jarg1;
25552   {
25553     try {
25554       delete arg1;
25555     } catch (std::out_of_range& e) {
25556       {
25557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25558       };
25559     } catch (std::exception& e) {
25560       {
25561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25562       };
25563     } catch (Dali::DaliException e) {
25564       {
25565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25566       };
25567     } catch (...) {
25568       {
25569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25570       };
25571     }
25572   }
25573
25574 }
25575
25576
25577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25578   void * jresult ;
25579   Dali::Geometry *arg1 = 0 ;
25580   Dali::Geometry *result = 0 ;
25581
25582   arg1 = (Dali::Geometry *)jarg1;
25583   if (!arg1) {
25584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25585     return 0;
25586   }
25587   {
25588     try {
25589       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25590     } catch (std::out_of_range& e) {
25591       {
25592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25593       };
25594     } catch (std::exception& e) {
25595       {
25596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25597       };
25598     } catch (Dali::DaliException e) {
25599       {
25600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25601       };
25602     } catch (...) {
25603       {
25604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25605       };
25606     }
25607   }
25608
25609   jresult = (void *)result;
25610   return jresult;
25611 }
25612
25613
25614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25615   void * jresult ;
25616   Dali::BaseHandle arg1 ;
25617   Dali::BaseHandle *argp1 ;
25618   Dali::Geometry result;
25619
25620   argp1 = (Dali::BaseHandle *)jarg1;
25621   if (!argp1) {
25622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25623     return 0;
25624   }
25625   arg1 = *argp1;
25626   {
25627     try {
25628       result = Dali::Geometry::DownCast(arg1);
25629     } catch (std::out_of_range& e) {
25630       {
25631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25632       };
25633     } catch (std::exception& e) {
25634       {
25635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25636       };
25637     } catch (Dali::DaliException e) {
25638       {
25639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25640       };
25641     } catch (...) {
25642       {
25643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25644       };
25645     }
25646   }
25647
25648   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25649   return jresult;
25650 }
25651
25652
25653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25654   void * jresult ;
25655   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25656   Dali::Geometry *arg2 = 0 ;
25657   Dali::Geometry *result = 0 ;
25658
25659   arg1 = (Dali::Geometry *)jarg1;
25660   arg2 = (Dali::Geometry *)jarg2;
25661   if (!arg2) {
25662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25663     return 0;
25664   }
25665   {
25666     try {
25667       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25668     } catch (std::out_of_range& e) {
25669       {
25670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25671       };
25672     } catch (std::exception& e) {
25673       {
25674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25675       };
25676     } catch (Dali::DaliException e) {
25677       {
25678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25679       };
25680     } catch (...) {
25681       {
25682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25683       };
25684     }
25685   }
25686
25687   jresult = (void *)result;
25688   return jresult;
25689 }
25690
25691
25692 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25693   unsigned long jresult ;
25694   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25695   Dali::PropertyBuffer *arg2 = 0 ;
25696   std::size_t result;
25697
25698   arg1 = (Dali::Geometry *)jarg1;
25699   arg2 = (Dali::PropertyBuffer *)jarg2;
25700   if (!arg2) {
25701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25702     return 0;
25703   }
25704   {
25705     try {
25706       result = (arg1)->AddVertexBuffer(*arg2);
25707     } catch (std::out_of_range& e) {
25708       {
25709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25710       };
25711     } catch (std::exception& e) {
25712       {
25713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25714       };
25715     } catch (Dali::DaliException e) {
25716       {
25717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25718       };
25719     } catch (...) {
25720       {
25721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25722       };
25723     }
25724   }
25725
25726   jresult = (unsigned long)result;
25727   return jresult;
25728 }
25729
25730
25731 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25732   unsigned long jresult ;
25733   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25734   std::size_t result;
25735
25736   arg1 = (Dali::Geometry *)jarg1;
25737   {
25738     try {
25739       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25740     } catch (std::out_of_range& e) {
25741       {
25742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25743       };
25744     } catch (std::exception& e) {
25745       {
25746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25747       };
25748     } catch (Dali::DaliException e) {
25749       {
25750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25751       };
25752     } catch (...) {
25753       {
25754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25755       };
25756     }
25757   }
25758
25759   jresult = (unsigned long)result;
25760   return jresult;
25761 }
25762
25763
25764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25765   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25766   std::size_t arg2 ;
25767
25768   arg1 = (Dali::Geometry *)jarg1;
25769   arg2 = (std::size_t)jarg2;
25770   {
25771     try {
25772       (arg1)->RemoveVertexBuffer(arg2);
25773     } catch (std::out_of_range& e) {
25774       {
25775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25776       };
25777     } catch (std::exception& e) {
25778       {
25779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25780       };
25781     } catch (Dali::DaliException e) {
25782       {
25783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25784       };
25785     } catch (...) {
25786       {
25787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25788       };
25789     }
25790   }
25791
25792 }
25793
25794
25795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25796   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25797   unsigned short *arg2 = (unsigned short *) 0 ;
25798   size_t arg3 ;
25799
25800   arg1 = (Dali::Geometry *)jarg1;
25801   arg2 = jarg2;
25802   arg3 = (size_t)jarg3;
25803   {
25804     try {
25805       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25806     } catch (std::out_of_range& e) {
25807       {
25808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25809       };
25810     } catch (std::exception& e) {
25811       {
25812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25813       };
25814     } catch (Dali::DaliException e) {
25815       {
25816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25817       };
25818     } catch (...) {
25819       {
25820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25821       };
25822     }
25823   }
25824
25825
25826
25827 }
25828
25829
25830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25831   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25832   Dali::Geometry::Type arg2 ;
25833
25834   arg1 = (Dali::Geometry *)jarg1;
25835   arg2 = (Dali::Geometry::Type)jarg2;
25836   {
25837     try {
25838       (arg1)->SetType(arg2);
25839     } catch (std::out_of_range& e) {
25840       {
25841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25842       };
25843     } catch (std::exception& e) {
25844       {
25845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25846       };
25847     } catch (Dali::DaliException e) {
25848       {
25849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25850       };
25851     } catch (...) {
25852       {
25853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25854       };
25855     }
25856   }
25857
25858 }
25859
25860
25861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25862   int jresult ;
25863   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25864   Dali::Geometry::Type result;
25865
25866   arg1 = (Dali::Geometry *)jarg1;
25867   {
25868     try {
25869       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25870     } catch (std::out_of_range& e) {
25871       {
25872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25873       };
25874     } catch (std::exception& e) {
25875       {
25876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25877       };
25878     } catch (Dali::DaliException e) {
25879       {
25880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25881       };
25882     } catch (...) {
25883       {
25884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25885       };
25886     }
25887   }
25888
25889   jresult = (int)result;
25890   return jresult;
25891 }
25892
25893
25894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25895   void * jresult ;
25896   Dali::Shader::Hint *result = 0 ;
25897
25898   {
25899     try {
25900       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25901     } catch (std::out_of_range& e) {
25902       {
25903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25904       };
25905     } catch (std::exception& e) {
25906       {
25907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25908       };
25909     } catch (Dali::DaliException e) {
25910       {
25911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25912       };
25913     } catch (...) {
25914       {
25915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25916       };
25917     }
25918   }
25919
25920   jresult = (void *)result;
25921   return jresult;
25922 }
25923
25924
25925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25926   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25927
25928   arg1 = (Dali::Shader::Hint *)jarg1;
25929   {
25930     try {
25931       delete arg1;
25932     } catch (std::out_of_range& e) {
25933       {
25934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25935       };
25936     } catch (std::exception& e) {
25937       {
25938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25939       };
25940     } catch (Dali::DaliException e) {
25941       {
25942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25943       };
25944     } catch (...) {
25945       {
25946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25947       };
25948     }
25949   }
25950
25951 }
25952
25953
25954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25955   int jresult ;
25956   int result;
25957
25958   result = (int)Dali::Shader::Property::PROGRAM;
25959   jresult = (int)result;
25960   return jresult;
25961 }
25962
25963
25964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25965   void * jresult ;
25966   Dali::Shader::Property *result = 0 ;
25967
25968   {
25969     try {
25970       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25971     } catch (std::out_of_range& e) {
25972       {
25973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25974       };
25975     } catch (std::exception& e) {
25976       {
25977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25978       };
25979     } catch (Dali::DaliException e) {
25980       {
25981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25982       };
25983     } catch (...) {
25984       {
25985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25986       };
25987     }
25988   }
25989
25990   jresult = (void *)result;
25991   return jresult;
25992 }
25993
25994
25995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
25996   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
25997
25998   arg1 = (Dali::Shader::Property *)jarg1;
25999   {
26000     try {
26001       delete arg1;
26002     } catch (std::out_of_range& e) {
26003       {
26004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26005       };
26006     } catch (std::exception& e) {
26007       {
26008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26009       };
26010     } catch (Dali::DaliException e) {
26011       {
26012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26013       };
26014     } catch (...) {
26015       {
26016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26017       };
26018     }
26019   }
26020
26021 }
26022
26023
26024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26025   void * jresult ;
26026   std::string *arg1 = 0 ;
26027   std::string *arg2 = 0 ;
26028   Dali::Shader::Hint::Value arg3 ;
26029   Dali::Shader result;
26030
26031   if (!jarg1) {
26032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26033     return 0;
26034   }
26035   std::string arg1_str(jarg1);
26036   arg1 = &arg1_str;
26037   if (!jarg2) {
26038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26039     return 0;
26040   }
26041   std::string arg2_str(jarg2);
26042   arg2 = &arg2_str;
26043   arg3 = (Dali::Shader::Hint::Value)jarg3;
26044   {
26045     try {
26046       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26047     } catch (std::out_of_range& e) {
26048       {
26049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26050       };
26051     } catch (std::exception& e) {
26052       {
26053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26054       };
26055     } catch (Dali::DaliException e) {
26056       {
26057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26058       };
26059     } catch (...) {
26060       {
26061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26062       };
26063     }
26064   }
26065
26066   jresult = new Dali::Shader((const Dali::Shader &)result);
26067
26068   //argout typemap for const std::string&
26069
26070
26071   //argout typemap for const std::string&
26072
26073   return jresult;
26074 }
26075
26076
26077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26078   void * jresult ;
26079   std::string *arg1 = 0 ;
26080   std::string *arg2 = 0 ;
26081   Dali::Shader result;
26082
26083   if (!jarg1) {
26084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26085     return 0;
26086   }
26087   std::string arg1_str(jarg1);
26088   arg1 = &arg1_str;
26089   if (!jarg2) {
26090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26091     return 0;
26092   }
26093   std::string arg2_str(jarg2);
26094   arg2 = &arg2_str;
26095   {
26096     try {
26097       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26098     } catch (std::out_of_range& e) {
26099       {
26100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26101       };
26102     } catch (std::exception& e) {
26103       {
26104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26105       };
26106     } catch (Dali::DaliException e) {
26107       {
26108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26109       };
26110     } catch (...) {
26111       {
26112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26113       };
26114     }
26115   }
26116
26117   jresult = new Dali::Shader((const Dali::Shader &)result);
26118
26119   //argout typemap for const std::string&
26120
26121
26122   //argout typemap for const std::string&
26123
26124   return jresult;
26125 }
26126
26127
26128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26129   void * jresult ;
26130   Dali::Shader *result = 0 ;
26131
26132   {
26133     try {
26134       result = (Dali::Shader *)new Dali::Shader();
26135     } catch (std::out_of_range& e) {
26136       {
26137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26138       };
26139     } catch (std::exception& e) {
26140       {
26141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26142       };
26143     } catch (Dali::DaliException e) {
26144       {
26145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26146       };
26147     } catch (...) {
26148       {
26149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26150       };
26151     }
26152   }
26153
26154   jresult = (void *)result;
26155   return jresult;
26156 }
26157
26158
26159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26160   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26161
26162   arg1 = (Dali::Shader *)jarg1;
26163   {
26164     try {
26165       delete arg1;
26166     } catch (std::out_of_range& e) {
26167       {
26168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26169       };
26170     } catch (std::exception& e) {
26171       {
26172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26173       };
26174     } catch (Dali::DaliException e) {
26175       {
26176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26177       };
26178     } catch (...) {
26179       {
26180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26181       };
26182     }
26183   }
26184
26185 }
26186
26187
26188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26189   void * jresult ;
26190   Dali::Shader *arg1 = 0 ;
26191   Dali::Shader *result = 0 ;
26192
26193   arg1 = (Dali::Shader *)jarg1;
26194   if (!arg1) {
26195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26196     return 0;
26197   }
26198   {
26199     try {
26200       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26201     } catch (std::out_of_range& e) {
26202       {
26203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26204       };
26205     } catch (std::exception& e) {
26206       {
26207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26208       };
26209     } catch (Dali::DaliException e) {
26210       {
26211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26212       };
26213     } catch (...) {
26214       {
26215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26216       };
26217     }
26218   }
26219
26220   jresult = (void *)result;
26221   return jresult;
26222 }
26223
26224
26225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26226   void * jresult ;
26227   Dali::BaseHandle arg1 ;
26228   Dali::BaseHandle *argp1 ;
26229   Dali::Shader result;
26230
26231   argp1 = (Dali::BaseHandle *)jarg1;
26232   if (!argp1) {
26233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26234     return 0;
26235   }
26236   arg1 = *argp1;
26237   {
26238     try {
26239       result = Dali::Shader::DownCast(arg1);
26240     } catch (std::out_of_range& e) {
26241       {
26242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26243       };
26244     } catch (std::exception& e) {
26245       {
26246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26247       };
26248     } catch (Dali::DaliException e) {
26249       {
26250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26251       };
26252     } catch (...) {
26253       {
26254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26255       };
26256     }
26257   }
26258
26259   jresult = new Dali::Shader((const Dali::Shader &)result);
26260   return jresult;
26261 }
26262
26263
26264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26265   void * jresult ;
26266   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26267   Dali::Shader *arg2 = 0 ;
26268   Dali::Shader *result = 0 ;
26269
26270   arg1 = (Dali::Shader *)jarg1;
26271   arg2 = (Dali::Shader *)jarg2;
26272   if (!arg2) {
26273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26274     return 0;
26275   }
26276   {
26277     try {
26278       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26279     } catch (std::out_of_range& e) {
26280       {
26281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26282       };
26283     } catch (std::exception& e) {
26284       {
26285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26286       };
26287     } catch (Dali::DaliException e) {
26288       {
26289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26290       };
26291     } catch (...) {
26292       {
26293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26294       };
26295     }
26296   }
26297
26298   jresult = (void *)result;
26299   return jresult;
26300 }
26301
26302
26303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26304   int jresult ;
26305   int result;
26306
26307   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26308   jresult = (int)result;
26309   return jresult;
26310 }
26311
26312
26313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26314   int jresult ;
26315   int result;
26316
26317   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26318   jresult = (int)result;
26319   return jresult;
26320 }
26321
26322
26323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26324   int jresult ;
26325   int result;
26326
26327   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26328   jresult = (int)result;
26329   return jresult;
26330 }
26331
26332
26333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26334   int jresult ;
26335   int result;
26336
26337   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26338   jresult = (int)result;
26339   return jresult;
26340 }
26341
26342
26343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26344   int jresult ;
26345   int result;
26346
26347   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26348   jresult = (int)result;
26349   return jresult;
26350 }
26351
26352
26353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26354   int jresult ;
26355   int result;
26356
26357   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26358   jresult = (int)result;
26359   return jresult;
26360 }
26361
26362
26363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26364   int jresult ;
26365   int result;
26366
26367   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26368   jresult = (int)result;
26369   return jresult;
26370 }
26371
26372
26373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26374   int jresult ;
26375   int result;
26376
26377   result = (int)Dali::Renderer::Property::BLEND_MODE;
26378   jresult = (int)result;
26379   return jresult;
26380 }
26381
26382
26383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26384   int jresult ;
26385   int result;
26386
26387   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26388   jresult = (int)result;
26389   return jresult;
26390 }
26391
26392
26393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26394   int jresult ;
26395   int result;
26396
26397   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26398   jresult = (int)result;
26399   return jresult;
26400 }
26401
26402
26403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26404   int jresult ;
26405   int result;
26406
26407   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26408   jresult = (int)result;
26409   return jresult;
26410 }
26411
26412
26413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26414   int jresult ;
26415   int result;
26416
26417   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26418   jresult = (int)result;
26419   return jresult;
26420 }
26421
26422
26423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26424   int jresult ;
26425   int result;
26426
26427   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26428   jresult = (int)result;
26429   return jresult;
26430 }
26431
26432
26433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26434   int jresult ;
26435   int result;
26436
26437   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26438   jresult = (int)result;
26439   return jresult;
26440 }
26441
26442
26443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26444   int jresult ;
26445   int result;
26446
26447   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26448   jresult = (int)result;
26449   return jresult;
26450 }
26451
26452
26453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26454   int jresult ;
26455   int result;
26456
26457   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26458   jresult = (int)result;
26459   return jresult;
26460 }
26461
26462
26463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26464   int jresult ;
26465   int result;
26466
26467   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26468   jresult = (int)result;
26469   return jresult;
26470 }
26471
26472
26473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26474   int jresult ;
26475   int result;
26476
26477   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26478   jresult = (int)result;
26479   return jresult;
26480 }
26481
26482
26483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26484   int jresult ;
26485   int result;
26486
26487   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26488   jresult = (int)result;
26489   return jresult;
26490 }
26491
26492
26493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26494   int jresult ;
26495   int result;
26496
26497   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26498   jresult = (int)result;
26499   return jresult;
26500 }
26501
26502
26503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26504   int jresult ;
26505   int result;
26506
26507   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26508   jresult = (int)result;
26509   return jresult;
26510 }
26511
26512
26513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26514   int jresult ;
26515   int result;
26516
26517   result = (int)Dali::Renderer::Property::RENDER_MODE;
26518   jresult = (int)result;
26519   return jresult;
26520 }
26521
26522
26523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26524   int jresult ;
26525   int result;
26526
26527   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26528   jresult = (int)result;
26529   return jresult;
26530 }
26531
26532
26533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26534   int jresult ;
26535   int result;
26536
26537   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26538   jresult = (int)result;
26539   return jresult;
26540 }
26541
26542
26543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26544   int jresult ;
26545   int result;
26546
26547   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26548   jresult = (int)result;
26549   return jresult;
26550 }
26551
26552
26553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26554   int jresult ;
26555   int result;
26556
26557   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26558   jresult = (int)result;
26559   return jresult;
26560 }
26561
26562
26563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26564   int jresult ;
26565   int result;
26566
26567   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26568   jresult = (int)result;
26569   return jresult;
26570 }
26571
26572
26573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26574   int jresult ;
26575   int result;
26576
26577   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26578   jresult = (int)result;
26579   return jresult;
26580 }
26581
26582
26583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26584   int jresult ;
26585   int result;
26586
26587   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26588   jresult = (int)result;
26589   return jresult;
26590 }
26591
26592
26593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26594   void * jresult ;
26595   Dali::Renderer::Property *result = 0 ;
26596
26597   {
26598     try {
26599       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26600     } catch (std::out_of_range& e) {
26601       {
26602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26603       };
26604     } catch (std::exception& e) {
26605       {
26606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26607       };
26608     } catch (Dali::DaliException e) {
26609       {
26610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26611       };
26612     } catch (...) {
26613       {
26614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26615       };
26616     }
26617   }
26618
26619   jresult = (void *)result;
26620   return jresult;
26621 }
26622
26623
26624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26625   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26626
26627   arg1 = (Dali::Renderer::Property *)jarg1;
26628   {
26629     try {
26630       delete arg1;
26631     } catch (std::out_of_range& e) {
26632       {
26633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26634       };
26635     } catch (std::exception& e) {
26636       {
26637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26638       };
26639     } catch (Dali::DaliException e) {
26640       {
26641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26642       };
26643     } catch (...) {
26644       {
26645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26646       };
26647     }
26648   }
26649
26650 }
26651
26652
26653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26654   void * jresult ;
26655   Dali::Geometry *arg1 = 0 ;
26656   Dali::Shader *arg2 = 0 ;
26657   Dali::Renderer result;
26658
26659   arg1 = (Dali::Geometry *)jarg1;
26660   if (!arg1) {
26661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26662     return 0;
26663   }
26664   arg2 = (Dali::Shader *)jarg2;
26665   if (!arg2) {
26666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26667     return 0;
26668   }
26669   {
26670     try {
26671       result = Dali::Renderer::New(*arg1,*arg2);
26672     } catch (std::out_of_range& e) {
26673       {
26674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26675       };
26676     } catch (std::exception& e) {
26677       {
26678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26679       };
26680     } catch (Dali::DaliException e) {
26681       {
26682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26683       };
26684     } catch (...) {
26685       {
26686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26687       };
26688     }
26689   }
26690
26691   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26692   return jresult;
26693 }
26694
26695
26696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26697   void * jresult ;
26698   Dali::Renderer *result = 0 ;
26699
26700   {
26701     try {
26702       result = (Dali::Renderer *)new Dali::Renderer();
26703     } catch (std::out_of_range& e) {
26704       {
26705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26706       };
26707     } catch (std::exception& e) {
26708       {
26709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26710       };
26711     } catch (Dali::DaliException e) {
26712       {
26713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26714       };
26715     } catch (...) {
26716       {
26717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26718       };
26719     }
26720   }
26721
26722   jresult = (void *)result;
26723   return jresult;
26724 }
26725
26726
26727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26728   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26729
26730   arg1 = (Dali::Renderer *)jarg1;
26731   {
26732     try {
26733       delete arg1;
26734     } catch (std::out_of_range& e) {
26735       {
26736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26737       };
26738     } catch (std::exception& e) {
26739       {
26740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26741       };
26742     } catch (Dali::DaliException e) {
26743       {
26744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26745       };
26746     } catch (...) {
26747       {
26748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26749       };
26750     }
26751   }
26752
26753 }
26754
26755
26756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26757   void * jresult ;
26758   Dali::Renderer *arg1 = 0 ;
26759   Dali::Renderer *result = 0 ;
26760
26761   arg1 = (Dali::Renderer *)jarg1;
26762   if (!arg1) {
26763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26764     return 0;
26765   }
26766   {
26767     try {
26768       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26769     } catch (std::out_of_range& e) {
26770       {
26771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26772       };
26773     } catch (std::exception& e) {
26774       {
26775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26776       };
26777     } catch (Dali::DaliException e) {
26778       {
26779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26780       };
26781     } catch (...) {
26782       {
26783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26784       };
26785     }
26786   }
26787
26788   jresult = (void *)result;
26789   return jresult;
26790 }
26791
26792
26793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26794   void * jresult ;
26795   Dali::BaseHandle arg1 ;
26796   Dali::BaseHandle *argp1 ;
26797   Dali::Renderer result;
26798
26799   argp1 = (Dali::BaseHandle *)jarg1;
26800   if (!argp1) {
26801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26802     return 0;
26803   }
26804   arg1 = *argp1;
26805   {
26806     try {
26807       result = Dali::Renderer::DownCast(arg1);
26808     } catch (std::out_of_range& e) {
26809       {
26810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26811       };
26812     } catch (std::exception& e) {
26813       {
26814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26815       };
26816     } catch (Dali::DaliException e) {
26817       {
26818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26819       };
26820     } catch (...) {
26821       {
26822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26823       };
26824     }
26825   }
26826
26827   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26828   return jresult;
26829 }
26830
26831
26832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26833   void * jresult ;
26834   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26835   Dali::Renderer *arg2 = 0 ;
26836   Dali::Renderer *result = 0 ;
26837
26838   arg1 = (Dali::Renderer *)jarg1;
26839   arg2 = (Dali::Renderer *)jarg2;
26840   if (!arg2) {
26841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26842     return 0;
26843   }
26844   {
26845     try {
26846       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26847     } catch (std::out_of_range& e) {
26848       {
26849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26850       };
26851     } catch (std::exception& e) {
26852       {
26853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26854       };
26855     } catch (Dali::DaliException e) {
26856       {
26857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26858       };
26859     } catch (...) {
26860       {
26861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26862       };
26863     }
26864   }
26865
26866   jresult = (void *)result;
26867   return jresult;
26868 }
26869
26870
26871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26872   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26873   Dali::Geometry *arg2 = 0 ;
26874
26875   arg1 = (Dali::Renderer *)jarg1;
26876   arg2 = (Dali::Geometry *)jarg2;
26877   if (!arg2) {
26878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26879     return ;
26880   }
26881   {
26882     try {
26883       (arg1)->SetGeometry(*arg2);
26884     } catch (std::out_of_range& e) {
26885       {
26886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26887       };
26888     } catch (std::exception& e) {
26889       {
26890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26891       };
26892     } catch (Dali::DaliException e) {
26893       {
26894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26895       };
26896     } catch (...) {
26897       {
26898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26899       };
26900     }
26901   }
26902
26903 }
26904
26905
26906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26907   void * jresult ;
26908   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26909   Dali::Geometry result;
26910
26911   arg1 = (Dali::Renderer *)jarg1;
26912   {
26913     try {
26914       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26915     } catch (std::out_of_range& e) {
26916       {
26917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26918       };
26919     } catch (std::exception& e) {
26920       {
26921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26922       };
26923     } catch (Dali::DaliException e) {
26924       {
26925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26926       };
26927     } catch (...) {
26928       {
26929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26930       };
26931     }
26932   }
26933
26934   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26935   return jresult;
26936 }
26937
26938
26939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26940   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26941   int arg2 ;
26942   int arg3 ;
26943
26944   arg1 = (Dali::Renderer *)jarg1;
26945   arg2 = (int)jarg2;
26946   arg3 = (int)jarg3;
26947   {
26948     try {
26949       (arg1)->SetIndexRange(arg2,arg3);
26950     } catch (std::out_of_range& e) {
26951       {
26952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26953       };
26954     } catch (std::exception& e) {
26955       {
26956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26957       };
26958     } catch (Dali::DaliException e) {
26959       {
26960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26961       };
26962     } catch (...) {
26963       {
26964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26965       };
26966     }
26967   }
26968
26969 }
26970
26971
26972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26973   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26974   Dali::TextureSet *arg2 = 0 ;
26975
26976   arg1 = (Dali::Renderer *)jarg1;
26977   arg2 = (Dali::TextureSet *)jarg2;
26978   if (!arg2) {
26979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26980     return ;
26981   }
26982   {
26983     try {
26984       (arg1)->SetTextures(*arg2);
26985     } catch (std::out_of_range& e) {
26986       {
26987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26988       };
26989     } catch (std::exception& e) {
26990       {
26991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26992       };
26993     } catch (Dali::DaliException e) {
26994       {
26995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26996       };
26997     } catch (...) {
26998       {
26999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27000       };
27001     }
27002   }
27003
27004 }
27005
27006
27007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27008   void * jresult ;
27009   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27010   Dali::TextureSet result;
27011
27012   arg1 = (Dali::Renderer *)jarg1;
27013   {
27014     try {
27015       result = ((Dali::Renderer const *)arg1)->GetTextures();
27016     } catch (std::out_of_range& e) {
27017       {
27018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27019       };
27020     } catch (std::exception& e) {
27021       {
27022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27023       };
27024     } catch (Dali::DaliException e) {
27025       {
27026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27027       };
27028     } catch (...) {
27029       {
27030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27031       };
27032     }
27033   }
27034
27035   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27036   return jresult;
27037 }
27038
27039
27040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27041   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27042   Dali::Shader *arg2 = 0 ;
27043
27044   arg1 = (Dali::Renderer *)jarg1;
27045   arg2 = (Dali::Shader *)jarg2;
27046   if (!arg2) {
27047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27048     return ;
27049   }
27050   {
27051     try {
27052       (arg1)->SetShader(*arg2);
27053     } catch (std::out_of_range& e) {
27054       {
27055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27056       };
27057     } catch (std::exception& e) {
27058       {
27059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27060       };
27061     } catch (Dali::DaliException e) {
27062       {
27063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27064       };
27065     } catch (...) {
27066       {
27067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27068       };
27069     }
27070   }
27071
27072 }
27073
27074
27075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27076   void * jresult ;
27077   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27078   Dali::Shader result;
27079
27080   arg1 = (Dali::Renderer *)jarg1;
27081   {
27082     try {
27083       result = ((Dali::Renderer const *)arg1)->GetShader();
27084     } catch (std::out_of_range& e) {
27085       {
27086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27087       };
27088     } catch (std::exception& e) {
27089       {
27090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27091       };
27092     } catch (Dali::DaliException e) {
27093       {
27094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27095       };
27096     } catch (...) {
27097       {
27098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27099       };
27100     }
27101   }
27102
27103   jresult = new Dali::Shader((const Dali::Shader &)result);
27104   return jresult;
27105 }
27106
27107
27108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27109   void * jresult ;
27110   Dali::FrameBuffer::Attachment *result = 0 ;
27111
27112   {
27113     try {
27114       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27115     } catch (std::out_of_range& e) {
27116       {
27117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27118       };
27119     } catch (std::exception& e) {
27120       {
27121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27122       };
27123     } catch (Dali::DaliException e) {
27124       {
27125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27126       };
27127     } catch (...) {
27128       {
27129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27130       };
27131     }
27132   }
27133
27134   jresult = (void *)result;
27135   return jresult;
27136 }
27137
27138
27139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27140   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27141
27142   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27143   {
27144     try {
27145       delete arg1;
27146     } catch (std::out_of_range& e) {
27147       {
27148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27149       };
27150     } catch (std::exception& e) {
27151       {
27152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27153       };
27154     } catch (Dali::DaliException e) {
27155       {
27156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27157       };
27158     } catch (...) {
27159       {
27160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27161       };
27162     }
27163   }
27164
27165 }
27166
27167
27168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27169   void * jresult ;
27170   unsigned int arg1 ;
27171   unsigned int arg2 ;
27172   unsigned int arg3 ;
27173   Dali::FrameBuffer result;
27174
27175   arg1 = (unsigned int)jarg1;
27176   arg2 = (unsigned int)jarg2;
27177   arg3 = (unsigned int)jarg3;
27178   {
27179     try {
27180       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27181     } catch (std::out_of_range& e) {
27182       {
27183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27184       };
27185     } catch (std::exception& e) {
27186       {
27187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27188       };
27189     } catch (Dali::DaliException e) {
27190       {
27191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27192       };
27193     } catch (...) {
27194       {
27195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27196       };
27197     }
27198   }
27199
27200   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27201   return jresult;
27202 }
27203
27204
27205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27206   void * jresult ;
27207   Dali::FrameBuffer *result = 0 ;
27208
27209   {
27210     try {
27211       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27212     } catch (std::out_of_range& e) {
27213       {
27214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27215       };
27216     } catch (std::exception& e) {
27217       {
27218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27219       };
27220     } catch (Dali::DaliException e) {
27221       {
27222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27223       };
27224     } catch (...) {
27225       {
27226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27227       };
27228     }
27229   }
27230
27231   jresult = (void *)result;
27232   return jresult;
27233 }
27234
27235
27236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27237   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27238
27239   arg1 = (Dali::FrameBuffer *)jarg1;
27240   {
27241     try {
27242       delete arg1;
27243     } catch (std::out_of_range& e) {
27244       {
27245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27246       };
27247     } catch (std::exception& e) {
27248       {
27249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27250       };
27251     } catch (Dali::DaliException e) {
27252       {
27253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27254       };
27255     } catch (...) {
27256       {
27257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27258       };
27259     }
27260   }
27261
27262 }
27263
27264
27265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27266   void * jresult ;
27267   Dali::FrameBuffer *arg1 = 0 ;
27268   Dali::FrameBuffer *result = 0 ;
27269
27270   arg1 = (Dali::FrameBuffer *)jarg1;
27271   if (!arg1) {
27272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27273     return 0;
27274   }
27275   {
27276     try {
27277       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27278     } catch (std::out_of_range& e) {
27279       {
27280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27281       };
27282     } catch (std::exception& e) {
27283       {
27284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27285       };
27286     } catch (Dali::DaliException e) {
27287       {
27288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27289       };
27290     } catch (...) {
27291       {
27292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27293       };
27294     }
27295   }
27296
27297   jresult = (void *)result;
27298   return jresult;
27299 }
27300
27301
27302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27303   void * jresult ;
27304   Dali::BaseHandle arg1 ;
27305   Dali::BaseHandle *argp1 ;
27306   Dali::FrameBuffer result;
27307
27308   argp1 = (Dali::BaseHandle *)jarg1;
27309   if (!argp1) {
27310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27311     return 0;
27312   }
27313   arg1 = *argp1;
27314   {
27315     try {
27316       result = Dali::FrameBuffer::DownCast(arg1);
27317     } catch (std::out_of_range& e) {
27318       {
27319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27320       };
27321     } catch (std::exception& e) {
27322       {
27323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27324       };
27325     } catch (Dali::DaliException e) {
27326       {
27327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27328       };
27329     } catch (...) {
27330       {
27331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27332       };
27333     }
27334   }
27335
27336   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27337   return jresult;
27338 }
27339
27340
27341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27342   void * jresult ;
27343   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27344   Dali::FrameBuffer *arg2 = 0 ;
27345   Dali::FrameBuffer *result = 0 ;
27346
27347   arg1 = (Dali::FrameBuffer *)jarg1;
27348   arg2 = (Dali::FrameBuffer *)jarg2;
27349   if (!arg2) {
27350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27351     return 0;
27352   }
27353   {
27354     try {
27355       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27356     } catch (std::out_of_range& e) {
27357       {
27358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27359       };
27360     } catch (std::exception& e) {
27361       {
27362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27363       };
27364     } catch (Dali::DaliException e) {
27365       {
27366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27367       };
27368     } catch (...) {
27369       {
27370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27371       };
27372     }
27373   }
27374
27375   jresult = (void *)result;
27376   return jresult;
27377 }
27378
27379
27380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27381   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27382   Dali::Texture *arg2 = 0 ;
27383
27384   arg1 = (Dali::FrameBuffer *)jarg1;
27385   arg2 = (Dali::Texture *)jarg2;
27386   if (!arg2) {
27387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27388     return ;
27389   }
27390   {
27391     try {
27392       (arg1)->AttachColorTexture(*arg2);
27393     } catch (std::out_of_range& e) {
27394       {
27395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27396       };
27397     } catch (std::exception& e) {
27398       {
27399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27400       };
27401     } catch (Dali::DaliException e) {
27402       {
27403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27404       };
27405     } catch (...) {
27406       {
27407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27408       };
27409     }
27410   }
27411
27412 }
27413
27414
27415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27416   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27417   Dali::Texture *arg2 = 0 ;
27418   unsigned int arg3 ;
27419   unsigned int arg4 ;
27420
27421   arg1 = (Dali::FrameBuffer *)jarg1;
27422   arg2 = (Dali::Texture *)jarg2;
27423   if (!arg2) {
27424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27425     return ;
27426   }
27427   arg3 = (unsigned int)jarg3;
27428   arg4 = (unsigned int)jarg4;
27429   {
27430     try {
27431       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27432     } catch (std::out_of_range& e) {
27433       {
27434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27435       };
27436     } catch (std::exception& e) {
27437       {
27438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27439       };
27440     } catch (Dali::DaliException e) {
27441       {
27442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27443       };
27444     } catch (...) {
27445       {
27446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27447       };
27448     }
27449   }
27450
27451 }
27452
27453
27454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27455   void * jresult ;
27456   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27457   Dali::Texture result;
27458
27459   arg1 = (Dali::FrameBuffer *)jarg1;
27460   {
27461     try {
27462       result = (arg1)->GetColorTexture();
27463     } catch (std::out_of_range& e) {
27464       {
27465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27466       };
27467     } catch (std::exception& e) {
27468       {
27469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27470       };
27471     } catch (Dali::DaliException e) {
27472       {
27473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27474       };
27475     } catch (...) {
27476       {
27477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27478       };
27479     }
27480   }
27481
27482   jresult = new Dali::Texture((const Dali::Texture &)result);
27483   return jresult;
27484 }
27485
27486
27487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27488   void * jresult ;
27489   Dali::RenderTaskList *result = 0 ;
27490
27491   {
27492     try {
27493       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27494     } catch (std::out_of_range& e) {
27495       {
27496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27497       };
27498     } catch (std::exception& e) {
27499       {
27500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27501       };
27502     } catch (Dali::DaliException e) {
27503       {
27504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27505       };
27506     } catch (...) {
27507       {
27508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27509       };
27510     }
27511   }
27512
27513   jresult = (void *)result;
27514   return jresult;
27515 }
27516
27517
27518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27519   void * jresult ;
27520   Dali::BaseHandle arg1 ;
27521   Dali::BaseHandle *argp1 ;
27522   Dali::RenderTaskList result;
27523
27524   argp1 = (Dali::BaseHandle *)jarg1;
27525   if (!argp1) {
27526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27527     return 0;
27528   }
27529   arg1 = *argp1;
27530   {
27531     try {
27532       result = Dali::RenderTaskList::DownCast(arg1);
27533     } catch (std::out_of_range& e) {
27534       {
27535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27536       };
27537     } catch (std::exception& e) {
27538       {
27539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27540       };
27541     } catch (Dali::DaliException e) {
27542       {
27543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27544       };
27545     } catch (...) {
27546       {
27547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27548       };
27549     }
27550   }
27551
27552   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27553   return jresult;
27554 }
27555
27556
27557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27558   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27559
27560   arg1 = (Dali::RenderTaskList *)jarg1;
27561   {
27562     try {
27563       delete arg1;
27564     } catch (std::out_of_range& e) {
27565       {
27566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27567       };
27568     } catch (std::exception& e) {
27569       {
27570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27571       };
27572     } catch (Dali::DaliException e) {
27573       {
27574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27575       };
27576     } catch (...) {
27577       {
27578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27579       };
27580     }
27581   }
27582
27583 }
27584
27585
27586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27587   void * jresult ;
27588   Dali::RenderTaskList *arg1 = 0 ;
27589   Dali::RenderTaskList *result = 0 ;
27590
27591   arg1 = (Dali::RenderTaskList *)jarg1;
27592   if (!arg1) {
27593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27594     return 0;
27595   }
27596   {
27597     try {
27598       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27599     } catch (std::out_of_range& e) {
27600       {
27601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27602       };
27603     } catch (std::exception& e) {
27604       {
27605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27606       };
27607     } catch (Dali::DaliException e) {
27608       {
27609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27610       };
27611     } catch (...) {
27612       {
27613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27614       };
27615     }
27616   }
27617
27618   jresult = (void *)result;
27619   return jresult;
27620 }
27621
27622
27623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27624   void * jresult ;
27625   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27626   Dali::RenderTaskList *arg2 = 0 ;
27627   Dali::RenderTaskList *result = 0 ;
27628
27629   arg1 = (Dali::RenderTaskList *)jarg1;
27630   arg2 = (Dali::RenderTaskList *)jarg2;
27631   if (!arg2) {
27632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27633     return 0;
27634   }
27635   {
27636     try {
27637       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27638     } catch (std::out_of_range& e) {
27639       {
27640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27641       };
27642     } catch (std::exception& e) {
27643       {
27644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27645       };
27646     } catch (Dali::DaliException e) {
27647       {
27648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27649       };
27650     } catch (...) {
27651       {
27652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27653       };
27654     }
27655   }
27656
27657   jresult = (void *)result;
27658   return jresult;
27659 }
27660
27661
27662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27663   void * jresult ;
27664   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27665   Dali::RenderTask result;
27666
27667   arg1 = (Dali::RenderTaskList *)jarg1;
27668   {
27669     try {
27670       result = (arg1)->CreateTask();
27671     } catch (std::out_of_range& e) {
27672       {
27673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27674       };
27675     } catch (std::exception& e) {
27676       {
27677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27678       };
27679     } catch (Dali::DaliException e) {
27680       {
27681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27682       };
27683     } catch (...) {
27684       {
27685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27686       };
27687     }
27688   }
27689
27690   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27691   return jresult;
27692 }
27693
27694
27695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27696   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27697   Dali::RenderTask arg2 ;
27698   Dali::RenderTask *argp2 ;
27699
27700   arg1 = (Dali::RenderTaskList *)jarg1;
27701   argp2 = (Dali::RenderTask *)jarg2;
27702   if (!argp2) {
27703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27704     return ;
27705   }
27706   arg2 = *argp2;
27707   {
27708     try {
27709       (arg1)->RemoveTask(arg2);
27710     } catch (std::out_of_range& e) {
27711       {
27712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27713       };
27714     } catch (std::exception& e) {
27715       {
27716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27717       };
27718     } catch (Dali::DaliException e) {
27719       {
27720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27721       };
27722     } catch (...) {
27723       {
27724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27725       };
27726     }
27727   }
27728
27729 }
27730
27731
27732 //// ===============================================end part 1 =================
27733
27734 //// ========================= part 2 ===============================
27735
27736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27737   unsigned int jresult ;
27738   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27739   unsigned int result;
27740
27741   arg1 = (Dali::RenderTaskList *)jarg1;
27742   {
27743     try {
27744       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27745     } catch (std::out_of_range& e) {
27746       {
27747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27748       };
27749     } catch (std::exception& e) {
27750       {
27751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27752       };
27753     } catch (Dali::DaliException e) {
27754       {
27755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27756       };
27757     } catch (...) {
27758       {
27759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27760       };
27761     }
27762   }
27763
27764   jresult = result;
27765   return jresult;
27766 }
27767
27768
27769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27770   void * jresult ;
27771   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27772   unsigned int arg2 ;
27773   Dali::RenderTask result;
27774
27775   arg1 = (Dali::RenderTaskList *)jarg1;
27776   arg2 = (unsigned int)jarg2;
27777   {
27778     try {
27779       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27780     } catch (std::out_of_range& e) {
27781       {
27782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27783       };
27784     } catch (std::exception& e) {
27785       {
27786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27787       };
27788     } catch (Dali::DaliException e) {
27789       {
27790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27791       };
27792     } catch (...) {
27793       {
27794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27795       };
27796     }
27797   }
27798
27799   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27800   return jresult;
27801 }
27802
27803
27804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27805   int jresult ;
27806   int result;
27807
27808   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27809   jresult = (int)result;
27810   return jresult;
27811 }
27812
27813
27814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27815   int jresult ;
27816   int result;
27817
27818   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27819   jresult = (int)result;
27820   return jresult;
27821 }
27822
27823
27824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27825   int jresult ;
27826   int result;
27827
27828   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27829   jresult = (int)result;
27830   return jresult;
27831 }
27832
27833
27834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27835   int jresult ;
27836   int result;
27837
27838   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27839   jresult = (int)result;
27840   return jresult;
27841 }
27842
27843
27844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27845   void * jresult ;
27846   Dali::RenderTask::Property *result = 0 ;
27847
27848   {
27849     try {
27850       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27851     } catch (std::out_of_range& e) {
27852       {
27853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27854       };
27855     } catch (std::exception& e) {
27856       {
27857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27858       };
27859     } catch (Dali::DaliException e) {
27860       {
27861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27862       };
27863     } catch (...) {
27864       {
27865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27866       };
27867     }
27868   }
27869
27870   jresult = (void *)result;
27871   return jresult;
27872 }
27873
27874
27875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27876   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27877
27878   arg1 = (Dali::RenderTask::Property *)jarg1;
27879   {
27880     try {
27881       delete arg1;
27882     } catch (std::out_of_range& e) {
27883       {
27884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27885       };
27886     } catch (std::exception& e) {
27887       {
27888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27889       };
27890     } catch (Dali::DaliException e) {
27891       {
27892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27893       };
27894     } catch (...) {
27895       {
27896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27897       };
27898     }
27899   }
27900
27901 }
27902
27903
27904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27905   void * jresult ;
27906   bool (*result)(Dali::Vector2 &) = 0 ;
27907
27908   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27909   jresult = (void *)result;
27910   return jresult;
27911 }
27912
27913
27914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27915   void * jresult ;
27916   bool (*result)(Dali::Vector2 &) = 0 ;
27917
27918   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27919   jresult = (void *)result;
27920   return jresult;
27921 }
27922
27923
27924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27925   unsigned int jresult ;
27926   bool result;
27927
27928   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27929   jresult = result;
27930   return jresult;
27931 }
27932
27933
27934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27935   unsigned int jresult ;
27936   bool result;
27937
27938   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27939   jresult = result;
27940   return jresult;
27941 }
27942
27943
27944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27945   void * jresult ;
27946   Dali::Vector4 *result = 0 ;
27947
27948   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27949   jresult = (void *)result;
27950   return jresult;
27951 }
27952
27953
27954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27955   unsigned int jresult ;
27956   bool result;
27957
27958   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27959   jresult = result;
27960   return jresult;
27961 }
27962
27963
27964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27965   unsigned int jresult ;
27966   bool result;
27967
27968   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27969   jresult = result;
27970   return jresult;
27971 }
27972
27973
27974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27975   unsigned int jresult ;
27976   unsigned int result;
27977
27978   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27979   jresult = result;
27980   return jresult;
27981 }
27982
27983
27984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27985   void * jresult ;
27986   Dali::RenderTask *result = 0 ;
27987
27988   {
27989     try {
27990       result = (Dali::RenderTask *)new Dali::RenderTask();
27991     } catch (std::out_of_range& e) {
27992       {
27993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27994       };
27995     } catch (std::exception& e) {
27996       {
27997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27998       };
27999     } catch (Dali::DaliException e) {
28000       {
28001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28002       };
28003     } catch (...) {
28004       {
28005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28006       };
28007     }
28008   }
28009
28010   jresult = (void *)result;
28011   return jresult;
28012 }
28013
28014
28015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28016   void * jresult ;
28017   Dali::BaseHandle arg1 ;
28018   Dali::BaseHandle *argp1 ;
28019   Dali::RenderTask result;
28020
28021   argp1 = (Dali::BaseHandle *)jarg1;
28022   if (!argp1) {
28023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28024     return 0;
28025   }
28026   arg1 = *argp1;
28027   {
28028     try {
28029       result = Dali::RenderTask::DownCast(arg1);
28030     } catch (std::out_of_range& e) {
28031       {
28032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28033       };
28034     } catch (std::exception& e) {
28035       {
28036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28037       };
28038     } catch (Dali::DaliException e) {
28039       {
28040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28041       };
28042     } catch (...) {
28043       {
28044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28045       };
28046     }
28047   }
28048
28049   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28050   return jresult;
28051 }
28052
28053
28054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28055   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28056
28057   arg1 = (Dali::RenderTask *)jarg1;
28058   {
28059     try {
28060       delete arg1;
28061     } catch (std::out_of_range& e) {
28062       {
28063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28064       };
28065     } catch (std::exception& e) {
28066       {
28067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28068       };
28069     } catch (Dali::DaliException e) {
28070       {
28071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28072       };
28073     } catch (...) {
28074       {
28075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28076       };
28077     }
28078   }
28079
28080 }
28081
28082
28083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28084   void * jresult ;
28085   Dali::RenderTask *arg1 = 0 ;
28086   Dali::RenderTask *result = 0 ;
28087
28088   arg1 = (Dali::RenderTask *)jarg1;
28089   if (!arg1) {
28090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28091     return 0;
28092   }
28093   {
28094     try {
28095       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28096     } catch (std::out_of_range& e) {
28097       {
28098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28099       };
28100     } catch (std::exception& e) {
28101       {
28102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28103       };
28104     } catch (Dali::DaliException e) {
28105       {
28106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28107       };
28108     } catch (...) {
28109       {
28110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28111       };
28112     }
28113   }
28114
28115   jresult = (void *)result;
28116   return jresult;
28117 }
28118
28119
28120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28121   void * jresult ;
28122   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28123   Dali::RenderTask *arg2 = 0 ;
28124   Dali::RenderTask *result = 0 ;
28125
28126   arg1 = (Dali::RenderTask *)jarg1;
28127   arg2 = (Dali::RenderTask *)jarg2;
28128   if (!arg2) {
28129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28130     return 0;
28131   }
28132   {
28133     try {
28134       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28135     } catch (std::out_of_range& e) {
28136       {
28137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28138       };
28139     } catch (std::exception& e) {
28140       {
28141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28142       };
28143     } catch (Dali::DaliException e) {
28144       {
28145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28146       };
28147     } catch (...) {
28148       {
28149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28150       };
28151     }
28152   }
28153
28154   jresult = (void *)result;
28155   return jresult;
28156 }
28157
28158
28159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28160   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28161   Dali::Actor arg2 ;
28162   Dali::Actor *argp2 ;
28163
28164   arg1 = (Dali::RenderTask *)jarg1;
28165   argp2 = (Dali::Actor *)jarg2;
28166   if (!argp2) {
28167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28168     return ;
28169   }
28170   arg2 = *argp2;
28171   {
28172     try {
28173       (arg1)->SetSourceActor(arg2);
28174     } catch (std::out_of_range& e) {
28175       {
28176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28177       };
28178     } catch (std::exception& e) {
28179       {
28180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28181       };
28182     } catch (Dali::DaliException e) {
28183       {
28184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28185       };
28186     } catch (...) {
28187       {
28188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28189       };
28190     }
28191   }
28192
28193 }
28194
28195
28196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28197   void * jresult ;
28198   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28199   Dali::Actor result;
28200
28201   arg1 = (Dali::RenderTask *)jarg1;
28202   {
28203     try {
28204       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28205     } catch (std::out_of_range& e) {
28206       {
28207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28208       };
28209     } catch (std::exception& e) {
28210       {
28211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28212       };
28213     } catch (Dali::DaliException e) {
28214       {
28215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28216       };
28217     } catch (...) {
28218       {
28219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28220       };
28221     }
28222   }
28223
28224   jresult = new Dali::Actor((const Dali::Actor &)result);
28225   return jresult;
28226 }
28227
28228
28229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28230   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28231   bool arg2 ;
28232
28233   arg1 = (Dali::RenderTask *)jarg1;
28234   arg2 = jarg2 ? true : false;
28235   {
28236     try {
28237       (arg1)->SetExclusive(arg2);
28238     } catch (std::out_of_range& e) {
28239       {
28240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28241       };
28242     } catch (std::exception& e) {
28243       {
28244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28245       };
28246     } catch (Dali::DaliException e) {
28247       {
28248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28249       };
28250     } catch (...) {
28251       {
28252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28253       };
28254     }
28255   }
28256
28257 }
28258
28259
28260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28261   unsigned int jresult ;
28262   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28263   bool result;
28264
28265   arg1 = (Dali::RenderTask *)jarg1;
28266   {
28267     try {
28268       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28269     } catch (std::out_of_range& e) {
28270       {
28271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28272       };
28273     } catch (std::exception& e) {
28274       {
28275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28276       };
28277     } catch (Dali::DaliException e) {
28278       {
28279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28280       };
28281     } catch (...) {
28282       {
28283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28284       };
28285     }
28286   }
28287
28288   jresult = result;
28289   return jresult;
28290 }
28291
28292
28293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28294   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28295   bool arg2 ;
28296
28297   arg1 = (Dali::RenderTask *)jarg1;
28298   arg2 = jarg2 ? true : false;
28299   {
28300     try {
28301       (arg1)->SetInputEnabled(arg2);
28302     } catch (std::out_of_range& e) {
28303       {
28304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28305       };
28306     } catch (std::exception& e) {
28307       {
28308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28309       };
28310     } catch (Dali::DaliException e) {
28311       {
28312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28313       };
28314     } catch (...) {
28315       {
28316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28317       };
28318     }
28319   }
28320
28321 }
28322
28323
28324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28325   unsigned int jresult ;
28326   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28327   bool result;
28328
28329   arg1 = (Dali::RenderTask *)jarg1;
28330   {
28331     try {
28332       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28333     } catch (std::out_of_range& e) {
28334       {
28335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28336       };
28337     } catch (std::exception& e) {
28338       {
28339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28340       };
28341     } catch (Dali::DaliException e) {
28342       {
28343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28344       };
28345     } catch (...) {
28346       {
28347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28348       };
28349     }
28350   }
28351
28352   jresult = result;
28353   return jresult;
28354 }
28355
28356
28357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28358   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28359   Dali::CameraActor arg2 ;
28360   Dali::CameraActor *argp2 ;
28361
28362   arg1 = (Dali::RenderTask *)jarg1;
28363   argp2 = (Dali::CameraActor *)jarg2;
28364   if (!argp2) {
28365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28366     return ;
28367   }
28368   arg2 = *argp2;
28369   {
28370     try {
28371       (arg1)->SetCameraActor(arg2);
28372     } catch (std::out_of_range& e) {
28373       {
28374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28375       };
28376     } catch (std::exception& e) {
28377       {
28378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28379       };
28380     } catch (Dali::DaliException e) {
28381       {
28382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28383       };
28384     } catch (...) {
28385       {
28386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28387       };
28388     }
28389   }
28390
28391 }
28392
28393
28394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28395   void * jresult ;
28396   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28397   Dali::CameraActor result;
28398
28399   arg1 = (Dali::RenderTask *)jarg1;
28400   {
28401     try {
28402       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28403     } catch (std::out_of_range& e) {
28404       {
28405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28406       };
28407     } catch (std::exception& e) {
28408       {
28409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28410       };
28411     } catch (Dali::DaliException e) {
28412       {
28413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28414       };
28415     } catch (...) {
28416       {
28417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28418       };
28419     }
28420   }
28421
28422   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28423   return jresult;
28424 }
28425
28426
28427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28428   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28429   Dali::FrameBuffer arg2 ;
28430   Dali::FrameBuffer *argp2 ;
28431
28432   arg1 = (Dali::RenderTask *)jarg1;
28433   argp2 = (Dali::FrameBuffer *)jarg2;
28434   if (!argp2) {
28435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28436     return ;
28437   }
28438   arg2 = *argp2;
28439   {
28440     try {
28441       (arg1)->SetFrameBuffer(arg2);
28442     } catch (std::out_of_range& e) {
28443       {
28444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28445       };
28446     } catch (std::exception& e) {
28447       {
28448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28449       };
28450     } catch (Dali::DaliException e) {
28451       {
28452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28453       };
28454     } catch (...) {
28455       {
28456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28457       };
28458     }
28459   }
28460
28461 }
28462
28463
28464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28465   void * jresult ;
28466   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28467   Dali::FrameBuffer result;
28468
28469   arg1 = (Dali::RenderTask *)jarg1;
28470   {
28471     try {
28472       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28473     } catch (std::out_of_range& e) {
28474       {
28475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28476       };
28477     } catch (std::exception& e) {
28478       {
28479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28480       };
28481     } catch (Dali::DaliException e) {
28482       {
28483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28484       };
28485     } catch (...) {
28486       {
28487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28488       };
28489     }
28490   }
28491
28492   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28493   return jresult;
28494 }
28495
28496
28497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28498   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28499   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28500
28501   arg1 = (Dali::RenderTask *)jarg1;
28502   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28503   {
28504     try {
28505       (arg1)->SetScreenToFrameBufferFunction(arg2);
28506     } catch (std::out_of_range& e) {
28507       {
28508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28509       };
28510     } catch (std::exception& e) {
28511       {
28512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28513       };
28514     } catch (Dali::DaliException e) {
28515       {
28516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28517       };
28518     } catch (...) {
28519       {
28520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28521       };
28522     }
28523   }
28524
28525 }
28526
28527
28528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28529   void * jresult ;
28530   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28531   Dali::RenderTask::ScreenToFrameBufferFunction result;
28532
28533   arg1 = (Dali::RenderTask *)jarg1;
28534   {
28535     try {
28536       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28537     } catch (std::out_of_range& e) {
28538       {
28539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28540       };
28541     } catch (std::exception& e) {
28542       {
28543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28544       };
28545     } catch (Dali::DaliException e) {
28546       {
28547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28548       };
28549     } catch (...) {
28550       {
28551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28552       };
28553     }
28554   }
28555
28556   jresult = (void *)result;
28557   return jresult;
28558 }
28559
28560
28561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28562   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28563   Dali::Actor arg2 ;
28564   Dali::Actor *argp2 ;
28565
28566   arg1 = (Dali::RenderTask *)jarg1;
28567   argp2 = (Dali::Actor *)jarg2;
28568   if (!argp2) {
28569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28570     return ;
28571   }
28572   arg2 = *argp2;
28573   {
28574     try {
28575       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28576     } catch (std::out_of_range& e) {
28577       {
28578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28579       };
28580     } catch (std::exception& e) {
28581       {
28582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28583       };
28584     } catch (Dali::DaliException e) {
28585       {
28586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28587       };
28588     } catch (...) {
28589       {
28590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28591       };
28592     }
28593   }
28594
28595 }
28596
28597
28598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28599   void * jresult ;
28600   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28601   Dali::Actor result;
28602
28603   arg1 = (Dali::RenderTask *)jarg1;
28604   {
28605     try {
28606       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28607     } catch (std::out_of_range& e) {
28608       {
28609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28610       };
28611     } catch (std::exception& e) {
28612       {
28613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28614       };
28615     } catch (Dali::DaliException e) {
28616       {
28617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28618       };
28619     } catch (...) {
28620       {
28621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28622       };
28623     }
28624   }
28625
28626   jresult = new Dali::Actor((const Dali::Actor &)result);
28627   return jresult;
28628 }
28629
28630
28631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28632   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28633   Dali::Vector2 arg2 ;
28634   Dali::Vector2 *argp2 ;
28635
28636   arg1 = (Dali::RenderTask *)jarg1;
28637   argp2 = (Dali::Vector2 *)jarg2;
28638   if (!argp2) {
28639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28640     return ;
28641   }
28642   arg2 = *argp2;
28643   {
28644     try {
28645       (arg1)->SetViewportPosition(arg2);
28646     } catch (std::out_of_range& e) {
28647       {
28648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28649       };
28650     } catch (std::exception& e) {
28651       {
28652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28653       };
28654     } catch (Dali::DaliException e) {
28655       {
28656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28657       };
28658     } catch (...) {
28659       {
28660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28661       };
28662     }
28663   }
28664
28665 }
28666
28667
28668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28669   void * jresult ;
28670   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28671   Dali::Vector2 result;
28672
28673   arg1 = (Dali::RenderTask *)jarg1;
28674   {
28675     try {
28676       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28677     } catch (std::out_of_range& e) {
28678       {
28679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28680       };
28681     } catch (std::exception& e) {
28682       {
28683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28684       };
28685     } catch (Dali::DaliException e) {
28686       {
28687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28688       };
28689     } catch (...) {
28690       {
28691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28692       };
28693     }
28694   }
28695
28696   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28697   return jresult;
28698 }
28699
28700
28701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28702   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28703   Dali::Vector2 arg2 ;
28704   Dali::Vector2 *argp2 ;
28705
28706   arg1 = (Dali::RenderTask *)jarg1;
28707   argp2 = (Dali::Vector2 *)jarg2;
28708   if (!argp2) {
28709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28710     return ;
28711   }
28712   arg2 = *argp2;
28713   {
28714     try {
28715       (arg1)->SetViewportSize(arg2);
28716     } catch (std::out_of_range& e) {
28717       {
28718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28719       };
28720     } catch (std::exception& e) {
28721       {
28722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28723       };
28724     } catch (Dali::DaliException e) {
28725       {
28726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28727       };
28728     } catch (...) {
28729       {
28730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28731       };
28732     }
28733   }
28734
28735 }
28736
28737
28738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28739   void * jresult ;
28740   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28741   Dali::Vector2 result;
28742
28743   arg1 = (Dali::RenderTask *)jarg1;
28744   {
28745     try {
28746       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28747     } catch (std::out_of_range& e) {
28748       {
28749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28750       };
28751     } catch (std::exception& e) {
28752       {
28753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28754       };
28755     } catch (Dali::DaliException e) {
28756       {
28757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28758       };
28759     } catch (...) {
28760       {
28761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28762       };
28763     }
28764   }
28765
28766   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28767   return jresult;
28768 }
28769
28770
28771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28772   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28773   Dali::Viewport arg2 ;
28774   Dali::Viewport *argp2 ;
28775
28776   arg1 = (Dali::RenderTask *)jarg1;
28777   argp2 = (Dali::Viewport *)jarg2;
28778   if (!argp2) {
28779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28780     return ;
28781   }
28782   arg2 = *argp2;
28783   {
28784     try {
28785       (arg1)->SetViewport(arg2);
28786     } catch (std::out_of_range& e) {
28787       {
28788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28789       };
28790     } catch (std::exception& e) {
28791       {
28792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28793       };
28794     } catch (Dali::DaliException e) {
28795       {
28796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28797       };
28798     } catch (...) {
28799       {
28800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28801       };
28802     }
28803   }
28804
28805 }
28806
28807
28808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28809   void * jresult ;
28810   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28811   Dali::Viewport result;
28812
28813   arg1 = (Dali::RenderTask *)jarg1;
28814   {
28815     try {
28816       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28817     } catch (std::out_of_range& e) {
28818       {
28819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28820       };
28821     } catch (std::exception& e) {
28822       {
28823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28824       };
28825     } catch (Dali::DaliException e) {
28826       {
28827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28828       };
28829     } catch (...) {
28830       {
28831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28832       };
28833     }
28834   }
28835
28836   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28837   return jresult;
28838 }
28839
28840
28841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28842   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28843   Dali::Vector4 *arg2 = 0 ;
28844
28845   arg1 = (Dali::RenderTask *)jarg1;
28846   arg2 = (Dali::Vector4 *)jarg2;
28847   if (!arg2) {
28848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28849     return ;
28850   }
28851   {
28852     try {
28853       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28854     } catch (std::out_of_range& e) {
28855       {
28856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28857       };
28858     } catch (std::exception& e) {
28859       {
28860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28861       };
28862     } catch (Dali::DaliException e) {
28863       {
28864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28865       };
28866     } catch (...) {
28867       {
28868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28869       };
28870     }
28871   }
28872
28873 }
28874
28875
28876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28877   void * jresult ;
28878   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28879   Dali::Vector4 result;
28880
28881   arg1 = (Dali::RenderTask *)jarg1;
28882   {
28883     try {
28884       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28885     } catch (std::out_of_range& e) {
28886       {
28887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28888       };
28889     } catch (std::exception& e) {
28890       {
28891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28892       };
28893     } catch (Dali::DaliException e) {
28894       {
28895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28896       };
28897     } catch (...) {
28898       {
28899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28900       };
28901     }
28902   }
28903
28904   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28905   return jresult;
28906 }
28907
28908
28909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28910   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28911   bool arg2 ;
28912
28913   arg1 = (Dali::RenderTask *)jarg1;
28914   arg2 = jarg2 ? true : false;
28915   {
28916     try {
28917       (arg1)->SetClearEnabled(arg2);
28918     } catch (std::out_of_range& e) {
28919       {
28920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28921       };
28922     } catch (std::exception& e) {
28923       {
28924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28925       };
28926     } catch (Dali::DaliException e) {
28927       {
28928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28929       };
28930     } catch (...) {
28931       {
28932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28933       };
28934     }
28935   }
28936
28937 }
28938
28939
28940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28941   unsigned int jresult ;
28942   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28943   bool result;
28944
28945   arg1 = (Dali::RenderTask *)jarg1;
28946   {
28947     try {
28948       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28949     } catch (std::out_of_range& e) {
28950       {
28951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28952       };
28953     } catch (std::exception& e) {
28954       {
28955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28956       };
28957     } catch (Dali::DaliException e) {
28958       {
28959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28960       };
28961     } catch (...) {
28962       {
28963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28964       };
28965     }
28966   }
28967
28968   jresult = result;
28969   return jresult;
28970 }
28971
28972
28973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28974   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28975   bool arg2 ;
28976
28977   arg1 = (Dali::RenderTask *)jarg1;
28978   arg2 = jarg2 ? true : false;
28979   {
28980     try {
28981       (arg1)->SetCullMode(arg2);
28982     } catch (std::out_of_range& e) {
28983       {
28984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28985       };
28986     } catch (std::exception& e) {
28987       {
28988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28989       };
28990     } catch (Dali::DaliException e) {
28991       {
28992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28993       };
28994     } catch (...) {
28995       {
28996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28997       };
28998     }
28999   }
29000
29001 }
29002
29003
29004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29005   unsigned int jresult ;
29006   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29007   bool result;
29008
29009   arg1 = (Dali::RenderTask *)jarg1;
29010   {
29011     try {
29012       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29013     } catch (std::out_of_range& e) {
29014       {
29015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29016       };
29017     } catch (std::exception& e) {
29018       {
29019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29020       };
29021     } catch (Dali::DaliException e) {
29022       {
29023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29024       };
29025     } catch (...) {
29026       {
29027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29028       };
29029     }
29030   }
29031
29032   jresult = result;
29033   return jresult;
29034 }
29035
29036
29037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29038   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29039   unsigned int arg2 ;
29040
29041   arg1 = (Dali::RenderTask *)jarg1;
29042   arg2 = (unsigned int)jarg2;
29043   {
29044     try {
29045       (arg1)->SetRefreshRate(arg2);
29046     } catch (std::out_of_range& e) {
29047       {
29048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29049       };
29050     } catch (std::exception& e) {
29051       {
29052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29053       };
29054     } catch (Dali::DaliException e) {
29055       {
29056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29057       };
29058     } catch (...) {
29059       {
29060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29061       };
29062     }
29063   }
29064
29065 }
29066
29067
29068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29069   unsigned int jresult ;
29070   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29071   unsigned int result;
29072
29073   arg1 = (Dali::RenderTask *)jarg1;
29074   {
29075     try {
29076       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29077     } catch (std::out_of_range& e) {
29078       {
29079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29080       };
29081     } catch (std::exception& e) {
29082       {
29083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29084       };
29085     } catch (Dali::DaliException e) {
29086       {
29087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29088       };
29089     } catch (...) {
29090       {
29091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29092       };
29093     }
29094   }
29095
29096   jresult = result;
29097   return jresult;
29098 }
29099
29100
29101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29102   unsigned int jresult ;
29103   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29104   Dali::Vector3 *arg2 = 0 ;
29105   float *arg3 = 0 ;
29106   float *arg4 = 0 ;
29107   bool result;
29108
29109   arg1 = (Dali::RenderTask *)jarg1;
29110   arg2 = (Dali::Vector3 *)jarg2;
29111   if (!arg2) {
29112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29113     return 0;
29114   }
29115   arg3 = (float *)jarg3;
29116   arg4 = (float *)jarg4;
29117   {
29118     try {
29119       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29120     } catch (std::out_of_range& e) {
29121       {
29122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29123       };
29124     } catch (std::exception& e) {
29125       {
29126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29127       };
29128     } catch (Dali::DaliException e) {
29129       {
29130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29131       };
29132     } catch (...) {
29133       {
29134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29135       };
29136     }
29137   }
29138
29139   jresult = result;
29140   return jresult;
29141 }
29142
29143
29144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29145   unsigned int jresult ;
29146   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29147   Dali::Actor arg2 ;
29148   float arg3 ;
29149   float arg4 ;
29150   float *arg5 = 0 ;
29151   float *arg6 = 0 ;
29152   Dali::Actor *argp2 ;
29153   bool result;
29154
29155   arg1 = (Dali::RenderTask *)jarg1;
29156   argp2 = (Dali::Actor *)jarg2;
29157   if (!argp2) {
29158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29159     return 0;
29160   }
29161   arg2 = *argp2;
29162   arg3 = (float)jarg3;
29163   arg4 = (float)jarg4;
29164   arg5 = (float *)jarg5;
29165   arg6 = (float *)jarg6;
29166   {
29167     try {
29168       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29169     } catch (std::out_of_range& e) {
29170       {
29171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29172       };
29173     } catch (std::exception& e) {
29174       {
29175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29176       };
29177     } catch (Dali::DaliException e) {
29178       {
29179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29180       };
29181     } catch (...) {
29182       {
29183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29184       };
29185     }
29186   }
29187
29188   jresult = result;
29189   return jresult;
29190 }
29191
29192
29193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29194   void * jresult ;
29195   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29196   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29197
29198   arg1 = (Dali::RenderTask *)jarg1;
29199   {
29200     try {
29201       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29202     } catch (std::out_of_range& e) {
29203       {
29204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29205       };
29206     } catch (std::exception& e) {
29207       {
29208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29209       };
29210     } catch (Dali::DaliException e) {
29211       {
29212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29213       };
29214     } catch (...) {
29215       {
29216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29217       };
29218     }
29219   }
29220
29221   jresult = (void *)result;
29222   return jresult;
29223 }
29224
29225
29226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29227   void * jresult ;
29228   int arg1 ;
29229   Dali::TouchPoint::State arg2 ;
29230   float arg3 ;
29231   float arg4 ;
29232   Dali::TouchPoint *result = 0 ;
29233
29234   arg1 = (int)jarg1;
29235   arg2 = (Dali::TouchPoint::State)jarg2;
29236   arg3 = (float)jarg3;
29237   arg4 = (float)jarg4;
29238   {
29239     try {
29240       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29241     } catch (std::out_of_range& e) {
29242       {
29243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29244       };
29245     } catch (std::exception& e) {
29246       {
29247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29248       };
29249     } catch (Dali::DaliException e) {
29250       {
29251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29252       };
29253     } catch (...) {
29254       {
29255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29256       };
29257     }
29258   }
29259
29260   jresult = (void *)result;
29261   return jresult;
29262 }
29263
29264
29265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29266   void * jresult ;
29267   int arg1 ;
29268   Dali::TouchPoint::State arg2 ;
29269   float arg3 ;
29270   float arg4 ;
29271   float arg5 ;
29272   float arg6 ;
29273   Dali::TouchPoint *result = 0 ;
29274
29275   arg1 = (int)jarg1;
29276   arg2 = (Dali::TouchPoint::State)jarg2;
29277   arg3 = (float)jarg3;
29278   arg4 = (float)jarg4;
29279   arg5 = (float)jarg5;
29280   arg6 = (float)jarg6;
29281   {
29282     try {
29283       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29284     } catch (std::out_of_range& e) {
29285       {
29286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29287       };
29288     } catch (std::exception& e) {
29289       {
29290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29291       };
29292     } catch (Dali::DaliException e) {
29293       {
29294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29295       };
29296     } catch (...) {
29297       {
29298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29299       };
29300     }
29301   }
29302
29303   jresult = (void *)result;
29304   return jresult;
29305 }
29306
29307
29308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29309   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29310
29311   arg1 = (Dali::TouchPoint *)jarg1;
29312   {
29313     try {
29314       delete arg1;
29315     } catch (std::out_of_range& e) {
29316       {
29317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29318       };
29319     } catch (std::exception& e) {
29320       {
29321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29322       };
29323     } catch (Dali::DaliException e) {
29324       {
29325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29326       };
29327     } catch (...) {
29328       {
29329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29330       };
29331     }
29332   }
29333
29334 }
29335
29336
29337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29338   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29339   int arg2 ;
29340
29341   arg1 = (Dali::TouchPoint *)jarg1;
29342   arg2 = (int)jarg2;
29343   if (arg1) (arg1)->deviceId = arg2;
29344 }
29345
29346
29347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29348   int jresult ;
29349   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29350   int result;
29351
29352   arg1 = (Dali::TouchPoint *)jarg1;
29353   result = (int) ((arg1)->deviceId);
29354   jresult = result;
29355   return jresult;
29356 }
29357
29358
29359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29360   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29361   Dali::TouchPoint::State arg2 ;
29362
29363   arg1 = (Dali::TouchPoint *)jarg1;
29364   arg2 = (Dali::TouchPoint::State)jarg2;
29365   if (arg1) (arg1)->state = arg2;
29366 }
29367
29368
29369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29370   int jresult ;
29371   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29372   Dali::TouchPoint::State result;
29373
29374   arg1 = (Dali::TouchPoint *)jarg1;
29375   result = (Dali::TouchPoint::State) ((arg1)->state);
29376   jresult = (int)result;
29377   return jresult;
29378 }
29379
29380
29381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29382   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29383   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29384
29385   arg1 = (Dali::TouchPoint *)jarg1;
29386   arg2 = (Dali::Actor *)jarg2;
29387   if (arg1) (arg1)->hitActor = *arg2;
29388 }
29389
29390
29391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29392   void * jresult ;
29393   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29394   Dali::Actor *result = 0 ;
29395
29396   arg1 = (Dali::TouchPoint *)jarg1;
29397   result = (Dali::Actor *)& ((arg1)->hitActor);
29398   jresult = (void *)result;
29399   return jresult;
29400 }
29401
29402
29403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29404   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29405   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29406
29407   arg1 = (Dali::TouchPoint *)jarg1;
29408   arg2 = (Dali::Vector2 *)jarg2;
29409   if (arg1) (arg1)->local = *arg2;
29410 }
29411
29412
29413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29414   void * jresult ;
29415   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29416   Dali::Vector2 *result = 0 ;
29417
29418   arg1 = (Dali::TouchPoint *)jarg1;
29419   result = (Dali::Vector2 *)& ((arg1)->local);
29420   jresult = (void *)result;
29421   return jresult;
29422 }
29423
29424
29425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29426   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29427   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29428
29429   arg1 = (Dali::TouchPoint *)jarg1;
29430   arg2 = (Dali::Vector2 *)jarg2;
29431   if (arg1) (arg1)->screen = *arg2;
29432 }
29433
29434
29435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29436   void * jresult ;
29437   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29438   Dali::Vector2 *result = 0 ;
29439
29440   arg1 = (Dali::TouchPoint *)jarg1;
29441   result = (Dali::Vector2 *)& ((arg1)->screen);
29442   jresult = (void *)result;
29443   return jresult;
29444 }
29445
29446
29447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29448   void * jresult ;
29449   Dali::TouchData *result = 0 ;
29450
29451   {
29452     try {
29453       result = (Dali::TouchData *)new Dali::TouchData();
29454     } catch (std::out_of_range& e) {
29455       {
29456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29457       };
29458     } catch (std::exception& e) {
29459       {
29460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29461       };
29462     } catch (Dali::DaliException e) {
29463       {
29464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29465       };
29466     } catch (...) {
29467       {
29468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29469       };
29470     }
29471   }
29472
29473   jresult = (void *)result;
29474   return jresult;
29475 }
29476
29477
29478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29479   void * jresult ;
29480   Dali::TouchData *arg1 = 0 ;
29481   Dali::TouchData *result = 0 ;
29482
29483   arg1 = (Dali::TouchData *)jarg1;
29484   if (!arg1) {
29485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29486     return 0;
29487   }
29488   {
29489     try {
29490       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29491     } catch (std::out_of_range& e) {
29492       {
29493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29494       };
29495     } catch (std::exception& e) {
29496       {
29497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29498       };
29499     } catch (Dali::DaliException e) {
29500       {
29501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29502       };
29503     } catch (...) {
29504       {
29505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29506       };
29507     }
29508   }
29509
29510   jresult = (void *)result;
29511   return jresult;
29512 }
29513
29514
29515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29516   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29517
29518   arg1 = (Dali::TouchData *)jarg1;
29519   {
29520     try {
29521       delete arg1;
29522     } catch (std::out_of_range& e) {
29523       {
29524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29525       };
29526     } catch (std::exception& e) {
29527       {
29528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29529       };
29530     } catch (Dali::DaliException e) {
29531       {
29532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29533       };
29534     } catch (...) {
29535       {
29536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29537       };
29538     }
29539   }
29540
29541 }
29542
29543
29544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29545   void * jresult ;
29546   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29547   Dali::TouchData *arg2 = 0 ;
29548   Dali::TouchData *result = 0 ;
29549
29550   arg1 = (Dali::TouchData *)jarg1;
29551   arg2 = (Dali::TouchData *)jarg2;
29552   if (!arg2) {
29553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29554     return 0;
29555   }
29556   {
29557     try {
29558       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29559     } catch (std::out_of_range& e) {
29560       {
29561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29562       };
29563     } catch (std::exception& e) {
29564       {
29565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29566       };
29567     } catch (Dali::DaliException e) {
29568       {
29569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29570       };
29571     } catch (...) {
29572       {
29573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29574       };
29575     }
29576   }
29577
29578   jresult = (void *)result;
29579   return jresult;
29580 }
29581
29582
29583 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29584   unsigned long jresult ;
29585   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29586   unsigned long result;
29587
29588   arg1 = (Dali::TouchData *)jarg1;
29589   {
29590     try {
29591       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29592     } catch (std::out_of_range& e) {
29593       {
29594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29595       };
29596     } catch (std::exception& e) {
29597       {
29598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29599       };
29600     } catch (Dali::DaliException e) {
29601       {
29602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29603       };
29604     } catch (...) {
29605       {
29606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29607       };
29608     }
29609   }
29610
29611   jresult = (unsigned long)result;
29612   return jresult;
29613 }
29614
29615
29616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29617   unsigned long jresult ;
29618   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29619   std::size_t result;
29620
29621   arg1 = (Dali::TouchData *)jarg1;
29622   {
29623     try {
29624       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29625     } catch (std::out_of_range& e) {
29626       {
29627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29628       };
29629     } catch (std::exception& e) {
29630       {
29631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29632       };
29633     } catch (Dali::DaliException e) {
29634       {
29635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29636       };
29637     } catch (...) {
29638       {
29639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29640       };
29641     }
29642   }
29643
29644   jresult = (unsigned long)result;
29645   return jresult;
29646 }
29647
29648
29649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29650   int jresult ;
29651   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29652   std::size_t arg2 ;
29653   int32_t result;
29654
29655   arg1 = (Dali::TouchData *)jarg1;
29656   arg2 = (std::size_t)jarg2;
29657   {
29658     try {
29659       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29660     } catch (std::out_of_range& e) {
29661       {
29662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29663       };
29664     } catch (std::exception& e) {
29665       {
29666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29667       };
29668     } catch (Dali::DaliException e) {
29669       {
29670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29671       };
29672     } catch (...) {
29673       {
29674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29675       };
29676     }
29677   }
29678
29679   jresult = result;
29680   return jresult;
29681 }
29682
29683
29684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29685   int jresult ;
29686   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29687   std::size_t arg2 ;
29688   Dali::PointState::Type result;
29689
29690   arg1 = (Dali::TouchData *)jarg1;
29691   arg2 = (std::size_t)jarg2;
29692   {
29693     try {
29694       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29695     } catch (std::out_of_range& e) {
29696       {
29697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29698       };
29699     } catch (std::exception& e) {
29700       {
29701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29702       };
29703     } catch (Dali::DaliException e) {
29704       {
29705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29706       };
29707     } catch (...) {
29708       {
29709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29710       };
29711     }
29712   }
29713
29714   jresult = (int)result;
29715   return jresult;
29716 }
29717
29718
29719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29720   void * jresult ;
29721   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29722   std::size_t arg2 ;
29723   Dali::Actor result;
29724
29725   arg1 = (Dali::TouchData *)jarg1;
29726   arg2 = (std::size_t)jarg2;
29727   {
29728     try {
29729       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29730     } catch (std::out_of_range& e) {
29731       {
29732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29733       };
29734     } catch (std::exception& e) {
29735       {
29736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29737       };
29738     } catch (Dali::DaliException e) {
29739       {
29740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29741       };
29742     } catch (...) {
29743       {
29744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29745       };
29746     }
29747   }
29748
29749   jresult = new Dali::Actor((const Dali::Actor &)result);
29750   return jresult;
29751 }
29752
29753
29754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29755   void * jresult ;
29756   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29757   std::size_t arg2 ;
29758   Dali::Vector2 *result = 0 ;
29759
29760   arg1 = (Dali::TouchData *)jarg1;
29761   arg2 = (std::size_t)jarg2;
29762   {
29763     try {
29764       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
29765     } catch (std::out_of_range& e) {
29766       {
29767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29768       };
29769     } catch (std::exception& e) {
29770       {
29771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29772       };
29773     } catch (Dali::DaliException e) {
29774       {
29775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29776       };
29777     } catch (...) {
29778       {
29779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29780       };
29781     }
29782   }
29783
29784   jresult = (void *)result;
29785   return jresult;
29786 }
29787
29788
29789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29790   void * jresult ;
29791   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29792   std::size_t arg2 ;
29793   Dali::Vector2 *result = 0 ;
29794
29795   arg1 = (Dali::TouchData *)jarg1;
29796   arg2 = (std::size_t)jarg2;
29797   {
29798     try {
29799       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
29800     } catch (std::out_of_range& e) {
29801       {
29802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29803       };
29804     } catch (std::exception& e) {
29805       {
29806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29807       };
29808     } catch (Dali::DaliException e) {
29809       {
29810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29811       };
29812     } catch (...) {
29813       {
29814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29815       };
29816     }
29817   }
29818
29819   jresult = (void *)result;
29820   return jresult;
29821 }
29822
29823
29824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29825   float jresult ;
29826   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29827   std::size_t arg2 ;
29828   float result;
29829
29830   arg1 = (Dali::TouchData *)jarg1;
29831   arg2 = (std::size_t)jarg2;
29832   {
29833     try {
29834       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
29835     } catch (std::out_of_range& e) {
29836       {
29837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29838       };
29839     } catch (std::exception& e) {
29840       {
29841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29842       };
29843     } catch (Dali::DaliException e) {
29844       {
29845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29846       };
29847     } catch (...) {
29848       {
29849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29850       };
29851     }
29852   }
29853
29854   jresult = result;
29855   return jresult;
29856 }
29857
29858
29859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29860   void * jresult ;
29861   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29862   std::size_t arg2 ;
29863   Dali::Vector2 *result = 0 ;
29864
29865   arg1 = (Dali::TouchData *)jarg1;
29866   arg2 = (std::size_t)jarg2;
29867   {
29868     try {
29869       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
29870     } catch (std::out_of_range& e) {
29871       {
29872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29873       };
29874     } catch (std::exception& e) {
29875       {
29876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29877       };
29878     } catch (Dali::DaliException e) {
29879       {
29880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29881       };
29882     } catch (...) {
29883       {
29884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29885       };
29886     }
29887   }
29888
29889   jresult = (void *)result;
29890   return jresult;
29891 }
29892
29893
29894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29895   float jresult ;
29896   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29897   std::size_t arg2 ;
29898   float result;
29899
29900   arg1 = (Dali::TouchData *)jarg1;
29901   arg2 = (std::size_t)jarg2;
29902   {
29903     try {
29904       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
29905     } catch (std::out_of_range& e) {
29906       {
29907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29908       };
29909     } catch (std::exception& e) {
29910       {
29911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29912       };
29913     } catch (Dali::DaliException e) {
29914       {
29915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29916       };
29917     } catch (...) {
29918       {
29919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29920       };
29921     }
29922   }
29923
29924   jresult = result;
29925   return jresult;
29926 }
29927
29928
29929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29930   void * jresult ;
29931   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29932   std::size_t arg2 ;
29933   Dali::Degree result;
29934
29935   arg1 = (Dali::TouchData *)jarg1;
29936   arg2 = (std::size_t)jarg2;
29937   {
29938     try {
29939       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
29940     } catch (std::out_of_range& e) {
29941       {
29942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29943       };
29944     } catch (std::exception& e) {
29945       {
29946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29947       };
29948     } catch (Dali::DaliException e) {
29949       {
29950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29951       };
29952     } catch (...) {
29953       {
29954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29955       };
29956     }
29957   }
29958
29959   jresult = new Dali::Degree((const Dali::Degree &)result);
29960   return jresult;
29961 }
29962
29963
29964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29965   int jresult ;
29966   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29967   std::size_t arg2 ;
29968   Dali::MouseButton::Type result;
29969
29970   arg1 = (Dali::TouchData *)jarg1;
29971   arg2 = (std::size_t)jarg2;
29972   {
29973     try {
29974       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
29975     } catch (std::out_of_range& e) {
29976       {
29977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29978       };
29979     } catch (std::exception& e) {
29980       {
29981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29982       };
29983     } catch (Dali::DaliException e) {
29984       {
29985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29986       };
29987     } catch (...) {
29988       {
29989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29990       };
29991     }
29992   }
29993
29994   jresult = static_cast< int >(result);
29995   return jresult;
29996 }
29997
29998
29999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30000   void * jresult ;
30001   Dali::GestureDetector *result = 0 ;
30002
30003   {
30004     try {
30005       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30006     } catch (std::out_of_range& e) {
30007       {
30008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30009       };
30010     } catch (std::exception& e) {
30011       {
30012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30013       };
30014     } catch (Dali::DaliException e) {
30015       {
30016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30017       };
30018     } catch (...) {
30019       {
30020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30021       };
30022     }
30023   }
30024
30025   jresult = (void *)result;
30026   return jresult;
30027 }
30028
30029
30030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30031   void * jresult ;
30032   Dali::BaseHandle arg1 ;
30033   Dali::BaseHandle *argp1 ;
30034   Dali::GestureDetector result;
30035
30036   argp1 = (Dali::BaseHandle *)jarg1;
30037   if (!argp1) {
30038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30039     return 0;
30040   }
30041   arg1 = *argp1;
30042   {
30043     try {
30044       result = Dali::GestureDetector::DownCast(arg1);
30045     } catch (std::out_of_range& e) {
30046       {
30047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30048       };
30049     } catch (std::exception& e) {
30050       {
30051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30052       };
30053     } catch (Dali::DaliException e) {
30054       {
30055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30056       };
30057     } catch (...) {
30058       {
30059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30060       };
30061     }
30062   }
30063
30064   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30065   return jresult;
30066 }
30067
30068
30069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30070   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30071
30072   arg1 = (Dali::GestureDetector *)jarg1;
30073   {
30074     try {
30075       delete arg1;
30076     } catch (std::out_of_range& e) {
30077       {
30078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30079       };
30080     } catch (std::exception& e) {
30081       {
30082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30083       };
30084     } catch (Dali::DaliException e) {
30085       {
30086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30087       };
30088     } catch (...) {
30089       {
30090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30091       };
30092     }
30093   }
30094
30095 }
30096
30097
30098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30099   void * jresult ;
30100   Dali::GestureDetector *arg1 = 0 ;
30101   Dali::GestureDetector *result = 0 ;
30102
30103   arg1 = (Dali::GestureDetector *)jarg1;
30104   if (!arg1) {
30105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30106     return 0;
30107   }
30108   {
30109     try {
30110       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30111     } catch (std::out_of_range& e) {
30112       {
30113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30114       };
30115     } catch (std::exception& e) {
30116       {
30117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30118       };
30119     } catch (Dali::DaliException e) {
30120       {
30121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30122       };
30123     } catch (...) {
30124       {
30125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30126       };
30127     }
30128   }
30129
30130   jresult = (void *)result;
30131   return jresult;
30132 }
30133
30134
30135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30136   void * jresult ;
30137   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30138   Dali::GestureDetector *arg2 = 0 ;
30139   Dali::GestureDetector *result = 0 ;
30140
30141   arg1 = (Dali::GestureDetector *)jarg1;
30142   arg2 = (Dali::GestureDetector *)jarg2;
30143   if (!arg2) {
30144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30145     return 0;
30146   }
30147   {
30148     try {
30149       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30150     } catch (std::out_of_range& e) {
30151       {
30152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30153       };
30154     } catch (std::exception& e) {
30155       {
30156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30157       };
30158     } catch (Dali::DaliException e) {
30159       {
30160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30161       };
30162     } catch (...) {
30163       {
30164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30165       };
30166     }
30167   }
30168
30169   jresult = (void *)result;
30170   return jresult;
30171 }
30172
30173
30174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30175   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30176   Dali::Actor arg2 ;
30177   Dali::Actor *argp2 ;
30178
30179   arg1 = (Dali::GestureDetector *)jarg1;
30180   argp2 = (Dali::Actor *)jarg2;
30181   if (!argp2) {
30182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30183     return ;
30184   }
30185   arg2 = *argp2;
30186   {
30187     try {
30188       (arg1)->Attach(arg2);
30189     } catch (std::out_of_range& e) {
30190       {
30191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30192       };
30193     } catch (std::exception& e) {
30194       {
30195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30196       };
30197     } catch (Dali::DaliException e) {
30198       {
30199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30200       };
30201     } catch (...) {
30202       {
30203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30204       };
30205     }
30206   }
30207
30208 }
30209
30210
30211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30212   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30213   Dali::Actor arg2 ;
30214   Dali::Actor *argp2 ;
30215
30216   arg1 = (Dali::GestureDetector *)jarg1;
30217   argp2 = (Dali::Actor *)jarg2;
30218   if (!argp2) {
30219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30220     return ;
30221   }
30222   arg2 = *argp2;
30223   {
30224     try {
30225       (arg1)->Detach(arg2);
30226     } catch (std::out_of_range& e) {
30227       {
30228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30229       };
30230     } catch (std::exception& e) {
30231       {
30232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30233       };
30234     } catch (Dali::DaliException e) {
30235       {
30236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30237       };
30238     } catch (...) {
30239       {
30240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30241       };
30242     }
30243   }
30244
30245 }
30246
30247
30248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30249   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30250
30251   arg1 = (Dali::GestureDetector *)jarg1;
30252   {
30253     try {
30254       (arg1)->DetachAll();
30255     } catch (std::out_of_range& e) {
30256       {
30257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30258       };
30259     } catch (std::exception& e) {
30260       {
30261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30262       };
30263     } catch (Dali::DaliException e) {
30264       {
30265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30266       };
30267     } catch (...) {
30268       {
30269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30270       };
30271     }
30272   }
30273
30274 }
30275
30276
30277 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30278   unsigned long jresult ;
30279   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30280   size_t result;
30281
30282   arg1 = (Dali::GestureDetector *)jarg1;
30283   {
30284     try {
30285       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30286     } catch (std::out_of_range& e) {
30287       {
30288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30289       };
30290     } catch (std::exception& e) {
30291       {
30292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30293       };
30294     } catch (Dali::DaliException e) {
30295       {
30296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30297       };
30298     } catch (...) {
30299       {
30300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30301       };
30302     }
30303   }
30304
30305   jresult = (unsigned long)result;
30306   return jresult;
30307 }
30308
30309
30310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30311   void * jresult ;
30312   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30313   size_t arg2 ;
30314   Dali::Actor result;
30315
30316   arg1 = (Dali::GestureDetector *)jarg1;
30317   arg2 = (size_t)jarg2;
30318   {
30319     try {
30320       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30321     } catch (std::out_of_range& e) {
30322       {
30323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30324       };
30325     } catch (std::exception& e) {
30326       {
30327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30328       };
30329     } catch (Dali::DaliException e) {
30330       {
30331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30332       };
30333     } catch (...) {
30334       {
30335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30336       };
30337     }
30338   }
30339
30340   jresult = new Dali::Actor((const Dali::Actor &)result);
30341   return jresult;
30342 }
30343
30344
30345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30346   void * jresult ;
30347   Dali::Gesture *arg1 = 0 ;
30348   Dali::Gesture *result = 0 ;
30349
30350   arg1 = (Dali::Gesture *)jarg1;
30351   if (!arg1) {
30352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30353     return 0;
30354   }
30355   {
30356     try {
30357       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30358     } catch (std::out_of_range& e) {
30359       {
30360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30361       };
30362     } catch (std::exception& e) {
30363       {
30364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30365       };
30366     } catch (Dali::DaliException e) {
30367       {
30368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30369       };
30370     } catch (...) {
30371       {
30372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30373       };
30374     }
30375   }
30376
30377   jresult = (void *)result;
30378   return jresult;
30379 }
30380
30381
30382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30383   void * jresult ;
30384   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30385   Dali::Gesture *arg2 = 0 ;
30386   Dali::Gesture *result = 0 ;
30387
30388   arg1 = (Dali::Gesture *)jarg1;
30389   arg2 = (Dali::Gesture *)jarg2;
30390   if (!arg2) {
30391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30392     return 0;
30393   }
30394   {
30395     try {
30396       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30397     } catch (std::out_of_range& e) {
30398       {
30399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30400       };
30401     } catch (std::exception& e) {
30402       {
30403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30404       };
30405     } catch (Dali::DaliException e) {
30406       {
30407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30408       };
30409     } catch (...) {
30410       {
30411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30412       };
30413     }
30414   }
30415
30416   jresult = (void *)result;
30417   return jresult;
30418 }
30419
30420
30421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30422   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30423
30424   arg1 = (Dali::Gesture *)jarg1;
30425   {
30426     try {
30427       delete arg1;
30428     } catch (std::out_of_range& e) {
30429       {
30430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30431       };
30432     } catch (std::exception& e) {
30433       {
30434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30435       };
30436     } catch (Dali::DaliException e) {
30437       {
30438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30439       };
30440     } catch (...) {
30441       {
30442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30443       };
30444     }
30445   }
30446
30447 }
30448
30449
30450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30451   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30452   Dali::Gesture::Type arg2 ;
30453
30454   arg1 = (Dali::Gesture *)jarg1;
30455   arg2 = (Dali::Gesture::Type)jarg2;
30456   if (arg1) (arg1)->type = arg2;
30457 }
30458
30459
30460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30461   int jresult ;
30462   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30463   Dali::Gesture::Type result;
30464
30465   arg1 = (Dali::Gesture *)jarg1;
30466   result = (Dali::Gesture::Type) ((arg1)->type);
30467   jresult = (int)result;
30468   return jresult;
30469 }
30470
30471
30472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30473   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30474   Dali::Gesture::State arg2 ;
30475
30476   arg1 = (Dali::Gesture *)jarg1;
30477   arg2 = (Dali::Gesture::State)jarg2;
30478   if (arg1) (arg1)->state = arg2;
30479 }
30480
30481
30482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30483   int jresult ;
30484   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30485   Dali::Gesture::State result;
30486
30487   arg1 = (Dali::Gesture *)jarg1;
30488   result = (Dali::Gesture::State) ((arg1)->state);
30489   jresult = (int)result;
30490   return jresult;
30491 }
30492
30493
30494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30495   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30496   unsigned int arg2 ;
30497
30498   arg1 = (Dali::Gesture *)jarg1;
30499   arg2 = (unsigned int)jarg2;
30500   if (arg1) (arg1)->time = arg2;
30501 }
30502
30503
30504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30505   unsigned int jresult ;
30506   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30507   unsigned int result;
30508
30509   arg1 = (Dali::Gesture *)jarg1;
30510   result = (unsigned int) ((arg1)->time);
30511   jresult = result;
30512   return jresult;
30513 }
30514
30515
30516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30517   void * jresult ;
30518   Dali::HoverEvent *result = 0 ;
30519
30520   {
30521     try {
30522       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30523     } catch (std::out_of_range& e) {
30524       {
30525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30526       };
30527     } catch (std::exception& e) {
30528       {
30529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30530       };
30531     } catch (Dali::DaliException e) {
30532       {
30533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30534       };
30535     } catch (...) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30538       };
30539     }
30540   }
30541
30542   jresult = (void *)result;
30543   return jresult;
30544 }
30545
30546
30547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30548   void * jresult ;
30549   unsigned long arg1 ;
30550   Dali::HoverEvent *result = 0 ;
30551
30552   arg1 = (unsigned long)jarg1;
30553   {
30554     try {
30555       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30556     } catch (std::out_of_range& e) {
30557       {
30558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30559       };
30560     } catch (std::exception& e) {
30561       {
30562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30563       };
30564     } catch (Dali::DaliException e) {
30565       {
30566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30567       };
30568     } catch (...) {
30569       {
30570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30571       };
30572     }
30573   }
30574
30575   jresult = (void *)result;
30576   return jresult;
30577 }
30578
30579
30580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30581   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30582
30583   arg1 = (Dali::HoverEvent *)jarg1;
30584   {
30585     try {
30586       delete arg1;
30587     } catch (std::out_of_range& e) {
30588       {
30589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30590       };
30591     } catch (std::exception& e) {
30592       {
30593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30594       };
30595     } catch (Dali::DaliException e) {
30596       {
30597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30598       };
30599     } catch (...) {
30600       {
30601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30602       };
30603     }
30604   }
30605
30606 }
30607
30608
30609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30610   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30611   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30612
30613   arg1 = (Dali::HoverEvent *)jarg1;
30614   arg2 = (Dali::TouchPointContainer *)jarg2;
30615   if (arg1) (arg1)->points = *arg2;
30616 }
30617
30618
30619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30620   void * jresult ;
30621   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30622   Dali::TouchPointContainer *result = 0 ;
30623
30624   arg1 = (Dali::HoverEvent *)jarg1;
30625   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30626   jresult = (void *)result;
30627   return jresult;
30628 }
30629
30630
30631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30632   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30633   unsigned long arg2 ;
30634
30635   arg1 = (Dali::HoverEvent *)jarg1;
30636   arg2 = (unsigned long)jarg2;
30637   if (arg1) (arg1)->time = arg2;
30638 }
30639
30640
30641 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30642   unsigned long jresult ;
30643   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30644   unsigned long result;
30645
30646   arg1 = (Dali::HoverEvent *)jarg1;
30647   result = (unsigned long) ((arg1)->time);
30648   jresult = (unsigned long)result;
30649   return jresult;
30650 }
30651
30652
30653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30654   unsigned int jresult ;
30655   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30656   unsigned int result;
30657
30658   arg1 = (Dali::HoverEvent *)jarg1;
30659   {
30660     try {
30661       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30662     } catch (std::out_of_range& e) {
30663       {
30664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30665       };
30666     } catch (std::exception& e) {
30667       {
30668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30669       };
30670     } catch (Dali::DaliException e) {
30671       {
30672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30673       };
30674     } catch (...) {
30675       {
30676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30677       };
30678     }
30679   }
30680
30681   jresult = result;
30682   return jresult;
30683 }
30684
30685
30686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30687   void * jresult ;
30688   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30689   unsigned int arg2 ;
30690   Dali::TouchPoint *result = 0 ;
30691
30692   arg1 = (Dali::HoverEvent *)jarg1;
30693   arg2 = (unsigned int)jarg2;
30694   {
30695     try {
30696       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30697     } catch (std::out_of_range& e) {
30698       {
30699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30700       };
30701     } catch (std::exception& e) {
30702       {
30703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30704       };
30705     } catch (Dali::DaliException e) {
30706       {
30707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30708       };
30709     } catch (...) {
30710       {
30711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30712       };
30713     }
30714   }
30715
30716   jresult = (void *)result;
30717   return jresult;
30718 }
30719
30720
30721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30722   void * jresult ;
30723   Dali::KeyEvent *result = 0 ;
30724
30725   {
30726     try {
30727       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30728     } catch (std::out_of_range& e) {
30729       {
30730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30731       };
30732     } catch (std::exception& e) {
30733       {
30734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30735       };
30736     } catch (Dali::DaliException e) {
30737       {
30738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30739       };
30740     } catch (...) {
30741       {
30742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30743       };
30744     }
30745   }
30746
30747   jresult = (void *)result;
30748   return jresult;
30749 }
30750
30751
30752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30753   void * jresult ;
30754   std::string *arg1 = 0 ;
30755   std::string *arg2 = 0 ;
30756   int arg3 ;
30757   int arg4 ;
30758   unsigned long arg5 ;
30759   Dali::KeyEvent::State *arg6 = 0 ;
30760   Dali::KeyEvent::State temp6 ;
30761   Dali::KeyEvent *result = 0 ;
30762
30763   if (!jarg1) {
30764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30765     return 0;
30766   }
30767   std::string arg1_str(jarg1);
30768   arg1 = &arg1_str;
30769   if (!jarg2) {
30770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30771     return 0;
30772   }
30773   std::string arg2_str(jarg2);
30774   arg2 = &arg2_str;
30775   arg3 = (int)jarg3;
30776   arg4 = (int)jarg4;
30777   arg5 = (unsigned long)jarg5;
30778   temp6 = (Dali::KeyEvent::State)jarg6;
30779   arg6 = &temp6;
30780   {
30781     try {
30782       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30783     } catch (std::out_of_range& e) {
30784       {
30785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30786       };
30787     } catch (std::exception& e) {
30788       {
30789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30790       };
30791     } catch (Dali::DaliException e) {
30792       {
30793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30794       };
30795     } catch (...) {
30796       {
30797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30798       };
30799     }
30800   }
30801
30802   jresult = (void *)result;
30803
30804   //argout typemap for const std::string&
30805
30806
30807   //argout typemap for const std::string&
30808
30809   return jresult;
30810 }
30811
30812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30813   void * jresult ;
30814   Dali::KeyEvent *arg1 = 0 ;
30815   Dali::KeyEvent *result = 0 ;
30816
30817   arg1 = (Dali::KeyEvent *)jarg1;
30818   if (!arg1) {
30819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30820     return 0;
30821   }
30822   {
30823     try {
30824       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30825     } catch (std::out_of_range& e) {
30826       {
30827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30828       };
30829     } catch (std::exception& e) {
30830       {
30831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30832       };
30833     } catch (Dali::DaliException e) {
30834       {
30835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30836       };
30837     } catch (...) {
30838       {
30839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30840       };
30841     }
30842   }
30843
30844   jresult = (void *)result;
30845   return jresult;
30846 }
30847
30848
30849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30850   void * jresult ;
30851   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30852   Dali::KeyEvent *arg2 = 0 ;
30853   Dali::KeyEvent *result = 0 ;
30854
30855   arg1 = (Dali::KeyEvent *)jarg1;
30856   arg2 = (Dali::KeyEvent *)jarg2;
30857   if (!arg2) {
30858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30859     return 0;
30860   }
30861   {
30862     try {
30863       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
30864     } catch (std::out_of_range& e) {
30865       {
30866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30867       };
30868     } catch (std::exception& e) {
30869       {
30870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30871       };
30872     } catch (Dali::DaliException e) {
30873       {
30874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30875       };
30876     } catch (...) {
30877       {
30878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30879       };
30880     }
30881   }
30882
30883   jresult = (void *)result;
30884   return jresult;
30885 }
30886
30887
30888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
30889   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30890
30891   arg1 = (Dali::KeyEvent *)jarg1;
30892   {
30893     try {
30894       delete arg1;
30895     } catch (std::out_of_range& e) {
30896       {
30897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30898       };
30899     } catch (std::exception& e) {
30900       {
30901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30902       };
30903     } catch (Dali::DaliException e) {
30904       {
30905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30906       };
30907     } catch (...) {
30908       {
30909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30910       };
30911     }
30912   }
30913
30914 }
30915
30916
30917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
30918   unsigned int jresult ;
30919   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30920   bool result;
30921
30922   arg1 = (Dali::KeyEvent *)jarg1;
30923   {
30924     try {
30925       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
30926     } catch (std::out_of_range& e) {
30927       {
30928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30929       };
30930     } catch (std::exception& e) {
30931       {
30932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30933       };
30934     } catch (Dali::DaliException e) {
30935       {
30936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30937       };
30938     } catch (...) {
30939       {
30940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30941       };
30942     }
30943   }
30944
30945   jresult = result;
30946   return jresult;
30947 }
30948
30949
30950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
30951   unsigned int jresult ;
30952   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30953   bool result;
30954
30955   arg1 = (Dali::KeyEvent *)jarg1;
30956   {
30957     try {
30958       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
30959     } catch (std::out_of_range& e) {
30960       {
30961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30962       };
30963     } catch (std::exception& e) {
30964       {
30965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30966       };
30967     } catch (Dali::DaliException e) {
30968       {
30969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30970       };
30971     } catch (...) {
30972       {
30973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30974       };
30975     }
30976   }
30977
30978   jresult = result;
30979   return jresult;
30980 }
30981
30982
30983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
30984   unsigned int jresult ;
30985   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30986   bool result;
30987
30988   arg1 = (Dali::KeyEvent *)jarg1;
30989   {
30990     try {
30991       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
30992     } catch (std::out_of_range& e) {
30993       {
30994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30995       };
30996     } catch (std::exception& e) {
30997       {
30998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30999       };
31000     } catch (Dali::DaliException e) {
31001       {
31002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31003       };
31004     } catch (...) {
31005       {
31006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31007       };
31008     }
31009   }
31010
31011   jresult = result;
31012   return jresult;
31013 }
31014
31015
31016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31017   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31018   std::string *arg2 = 0 ;
31019
31020   arg1 = (Dali::KeyEvent *)jarg1;
31021   if (!jarg2) {
31022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31023     return ;
31024   }
31025   std::string arg2_str(jarg2);
31026   arg2 = &arg2_str;
31027   if (arg1) (arg1)->keyPressedName = *arg2;
31028
31029   //argout typemap for const std::string&
31030
31031 }
31032
31033
31034 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31035   char * jresult ;
31036
31037   if( jarg1 == NULL )
31038   {
31039     jresult = SWIG_csharp_string_callback( "" );
31040   }
31041   else
31042   {
31043     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31044     std::string *result = 0;
31045
31046     arg1 = ( Dali::KeyEvent * )jarg1;
31047     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31048     jresult = SWIG_csharp_string_callback( result->c_str() );
31049   }
31050
31051   return jresult;
31052 }
31053
31054
31055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31056   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31057   std::string *arg2 = 0 ;
31058
31059   arg1 = (Dali::KeyEvent *)jarg1;
31060   if (!jarg2) {
31061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31062     return ;
31063   }
31064   std::string arg2_str(jarg2);
31065   arg2 = &arg2_str;
31066   if (arg1) (arg1)->keyPressed = *arg2;
31067
31068   //argout typemap for const std::string&
31069
31070 }
31071
31072
31073 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31074   char * jresult ;
31075   if( NULL == jarg1 )
31076   {
31077     jresult = SWIG_csharp_string_callback( "" );
31078   }
31079   else
31080   {
31081     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31082     std::string *result = 0;
31083
31084     arg1 = ( Dali::KeyEvent * )jarg1;
31085     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31086     jresult = SWIG_csharp_string_callback( result->c_str() );
31087   }
31088   return jresult;
31089 }
31090
31091
31092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31093   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31094   int arg2 ;
31095
31096   arg1 = (Dali::KeyEvent *)jarg1;
31097   arg2 = (int)jarg2;
31098   if (arg1) (arg1)->keyCode = arg2;
31099 }
31100
31101
31102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31103   int jresult ;
31104   if( NULL == jarg1 )
31105   {
31106     jresult = -1;
31107   }
31108   else
31109   {
31110     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31111     int result;
31112
31113     arg1 = ( Dali::KeyEvent * )jarg1;
31114     result = (int)( ( arg1 )->keyCode );
31115     jresult = result;
31116   }
31117   return jresult;
31118 }
31119
31120
31121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31122   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31123   int arg2 ;
31124
31125   arg1 = (Dali::KeyEvent *)jarg1;
31126   arg2 = (int)jarg2;
31127   if (arg1) (arg1)->keyModifier = arg2;
31128 }
31129
31130
31131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31132   int jresult ;
31133   if( jarg1 == NULL )
31134   {
31135     jresult = -1;
31136   }
31137   else
31138   {
31139     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31140     int result;
31141
31142     arg1 = ( Dali::KeyEvent * )jarg1;
31143     result = (int)( ( arg1 )->keyModifier );
31144     jresult = result;
31145   }
31146   return jresult;
31147 }
31148
31149
31150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31151   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31152   unsigned long arg2 ;
31153
31154   arg1 = (Dali::KeyEvent *)jarg1;
31155   arg2 = (unsigned long)jarg2;
31156   if (arg1) (arg1)->time = arg2;
31157 }
31158
31159
31160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31161   unsigned long jresult ;
31162   if( jarg1 == NULL )
31163   {
31164     jresult = 0;
31165   }
31166   else
31167   {
31168     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31169     unsigned long result;
31170
31171     arg1 = ( Dali::KeyEvent * )jarg1;
31172     result = (unsigned long)( ( arg1 )->time );
31173     jresult = (unsigned long)result;
31174   }
31175   return jresult;
31176 }
31177
31178
31179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31180   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31181   Dali::KeyEvent::State arg2 ;
31182
31183   arg1 = (Dali::KeyEvent *)jarg1;
31184   arg2 = (Dali::KeyEvent::State)jarg2;
31185   if (arg1) (arg1)->state = arg2;
31186 }
31187
31188
31189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31190   int jresult ;
31191   if( jarg1 == NULL )
31192   {
31193     jresult = -1;
31194   }
31195   else
31196   {
31197     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31198     Dali::KeyEvent::State result;
31199
31200     arg1 = ( Dali::KeyEvent * )jarg1;
31201     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31202     jresult = (int)result;
31203   }
31204   return jresult;
31205 }
31206
31207 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31208   char * jresult ;
31209   std::string result;
31210   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31211
31212   arg1 = (Dali::KeyEvent *)jarg1;
31213   if (!arg1) {
31214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31215     return 0;
31216   }
31217   {
31218     try {
31219       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31220     } catch (std::out_of_range& e) {
31221       {
31222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31223       };
31224     } catch (std::exception& e) {
31225       {
31226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31227       };
31228     } catch (Dali::DaliException e) {
31229       {
31230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31231       };
31232     } catch (...) {
31233       {
31234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31235       };
31236     }
31237
31238   }
31239
31240   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31241   return jresult;
31242 }
31243
31244
31245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31246   void * jresult ;
31247   Dali::LongPressGestureDetector *result = 0 ;
31248
31249   {
31250     try {
31251       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31252     } catch (std::out_of_range& e) {
31253       {
31254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31255       };
31256     } catch (std::exception& e) {
31257       {
31258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31259       };
31260     } catch (Dali::DaliException e) {
31261       {
31262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31263       };
31264     } catch (...) {
31265       {
31266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31267       };
31268     }
31269   }
31270
31271   jresult = (void *)result;
31272   return jresult;
31273 }
31274
31275
31276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31277   void * jresult ;
31278   Dali::LongPressGestureDetector result;
31279
31280   {
31281     try {
31282       result = Dali::LongPressGestureDetector::New();
31283     } catch (std::out_of_range& e) {
31284       {
31285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31286       };
31287     } catch (std::exception& e) {
31288       {
31289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31290       };
31291     } catch (Dali::DaliException e) {
31292       {
31293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31294       };
31295     } catch (...) {
31296       {
31297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31298       };
31299     }
31300   }
31301
31302   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31303   return jresult;
31304 }
31305
31306
31307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31308   void * jresult ;
31309   unsigned int arg1 ;
31310   Dali::LongPressGestureDetector result;
31311
31312   arg1 = (unsigned int)jarg1;
31313   {
31314     try {
31315       result = Dali::LongPressGestureDetector::New(arg1);
31316     } catch (std::out_of_range& e) {
31317       {
31318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31319       };
31320     } catch (std::exception& e) {
31321       {
31322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31323       };
31324     } catch (Dali::DaliException e) {
31325       {
31326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31327       };
31328     } catch (...) {
31329       {
31330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31331       };
31332     }
31333   }
31334
31335   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31336   return jresult;
31337 }
31338
31339
31340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31341   void * jresult ;
31342   unsigned int arg1 ;
31343   unsigned int arg2 ;
31344   Dali::LongPressGestureDetector result;
31345
31346   arg1 = (unsigned int)jarg1;
31347   arg2 = (unsigned int)jarg2;
31348   {
31349     try {
31350       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31351     } catch (std::out_of_range& e) {
31352       {
31353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31354       };
31355     } catch (std::exception& e) {
31356       {
31357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31358       };
31359     } catch (Dali::DaliException e) {
31360       {
31361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31362       };
31363     } catch (...) {
31364       {
31365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31366       };
31367     }
31368   }
31369
31370   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31371   return jresult;
31372 }
31373
31374
31375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31376   void * jresult ;
31377   Dali::BaseHandle arg1 ;
31378   Dali::BaseHandle *argp1 ;
31379   Dali::LongPressGestureDetector result;
31380
31381   argp1 = (Dali::BaseHandle *)jarg1;
31382   if (!argp1) {
31383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31384     return 0;
31385   }
31386   arg1 = *argp1;
31387   {
31388     try {
31389       result = Dali::LongPressGestureDetector::DownCast(arg1);
31390     } catch (std::out_of_range& e) {
31391       {
31392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31393       };
31394     } catch (std::exception& e) {
31395       {
31396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31397       };
31398     } catch (Dali::DaliException e) {
31399       {
31400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31401       };
31402     } catch (...) {
31403       {
31404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31405       };
31406     }
31407   }
31408
31409   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31410   return jresult;
31411 }
31412
31413
31414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31415   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31416
31417   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31418   {
31419     try {
31420       delete arg1;
31421     } catch (std::out_of_range& e) {
31422       {
31423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31424       };
31425     } catch (std::exception& e) {
31426       {
31427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31428       };
31429     } catch (Dali::DaliException e) {
31430       {
31431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31432       };
31433     } catch (...) {
31434       {
31435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31436       };
31437     }
31438   }
31439
31440 }
31441
31442
31443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31444   void * jresult ;
31445   Dali::LongPressGestureDetector *arg1 = 0 ;
31446   Dali::LongPressGestureDetector *result = 0 ;
31447
31448   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31449   if (!arg1) {
31450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31451     return 0;
31452   }
31453   {
31454     try {
31455       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31456     } catch (std::out_of_range& e) {
31457       {
31458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31459       };
31460     } catch (std::exception& e) {
31461       {
31462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31463       };
31464     } catch (Dali::DaliException e) {
31465       {
31466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31467       };
31468     } catch (...) {
31469       {
31470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31471       };
31472     }
31473   }
31474
31475   jresult = (void *)result;
31476   return jresult;
31477 }
31478
31479
31480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31481   void * jresult ;
31482   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31483   Dali::LongPressGestureDetector *arg2 = 0 ;
31484   Dali::LongPressGestureDetector *result = 0 ;
31485
31486   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31487   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31488   if (!arg2) {
31489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31490     return 0;
31491   }
31492   {
31493     try {
31494       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31495     } catch (std::out_of_range& e) {
31496       {
31497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31498       };
31499     } catch (std::exception& e) {
31500       {
31501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31502       };
31503     } catch (Dali::DaliException e) {
31504       {
31505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31506       };
31507     } catch (...) {
31508       {
31509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31510       };
31511     }
31512   }
31513
31514   jresult = (void *)result;
31515   return jresult;
31516 }
31517
31518
31519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31520   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31521   unsigned int arg2 ;
31522
31523   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31524   arg2 = (unsigned int)jarg2;
31525   {
31526     try {
31527       (arg1)->SetTouchesRequired(arg2);
31528     } catch (std::out_of_range& e) {
31529       {
31530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31531       };
31532     } catch (std::exception& e) {
31533       {
31534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31535       };
31536     } catch (Dali::DaliException e) {
31537       {
31538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31539       };
31540     } catch (...) {
31541       {
31542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31543       };
31544     }
31545   }
31546
31547 }
31548
31549
31550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31551   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31552   unsigned int arg2 ;
31553   unsigned int arg3 ;
31554
31555   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31556   arg2 = (unsigned int)jarg2;
31557   arg3 = (unsigned int)jarg3;
31558   {
31559     try {
31560       (arg1)->SetTouchesRequired(arg2,arg3);
31561     } catch (std::out_of_range& e) {
31562       {
31563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31564       };
31565     } catch (std::exception& e) {
31566       {
31567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31568       };
31569     } catch (Dali::DaliException e) {
31570       {
31571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31572       };
31573     } catch (...) {
31574       {
31575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31576       };
31577     }
31578   }
31579
31580 }
31581
31582
31583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31584   unsigned int jresult ;
31585   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31586   unsigned int result;
31587
31588   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31589   {
31590     try {
31591       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31592     } catch (std::out_of_range& e) {
31593       {
31594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31595       };
31596     } catch (std::exception& e) {
31597       {
31598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31599       };
31600     } catch (Dali::DaliException e) {
31601       {
31602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31603       };
31604     } catch (...) {
31605       {
31606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31607       };
31608     }
31609   }
31610
31611   jresult = result;
31612   return jresult;
31613 }
31614
31615
31616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31617   unsigned int jresult ;
31618   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31619   unsigned int result;
31620
31621   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31622   {
31623     try {
31624       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31625     } catch (std::out_of_range& e) {
31626       {
31627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31628       };
31629     } catch (std::exception& e) {
31630       {
31631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31632       };
31633     } catch (Dali::DaliException e) {
31634       {
31635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31636       };
31637     } catch (...) {
31638       {
31639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31640       };
31641     }
31642   }
31643
31644   jresult = result;
31645   return jresult;
31646 }
31647
31648
31649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31650   void * jresult ;
31651   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31652   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31653
31654   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31655   {
31656     try {
31657       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31658     } catch (std::out_of_range& e) {
31659       {
31660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31661       };
31662     } catch (std::exception& e) {
31663       {
31664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31665       };
31666     } catch (Dali::DaliException e) {
31667       {
31668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31669       };
31670     } catch (...) {
31671       {
31672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31673       };
31674     }
31675   }
31676
31677   jresult = (void *)result;
31678   return jresult;
31679 }
31680
31681
31682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31683   void * jresult ;
31684   Dali::Gesture::State arg1 ;
31685   Dali::LongPressGesture *result = 0 ;
31686
31687   arg1 = (Dali::Gesture::State)jarg1;
31688   {
31689     try {
31690       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31691     } catch (std::out_of_range& e) {
31692       {
31693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31694       };
31695     } catch (std::exception& e) {
31696       {
31697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31698       };
31699     } catch (Dali::DaliException e) {
31700       {
31701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31706       };
31707     }
31708   }
31709
31710   jresult = (void *)result;
31711   return jresult;
31712 }
31713
31714
31715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31716   void * jresult ;
31717   Dali::LongPressGesture *arg1 = 0 ;
31718   Dali::LongPressGesture *result = 0 ;
31719
31720   arg1 = (Dali::LongPressGesture *)jarg1;
31721   if (!arg1) {
31722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31723     return 0;
31724   }
31725   {
31726     try {
31727       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31728     } catch (std::out_of_range& e) {
31729       {
31730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31731       };
31732     } catch (std::exception& e) {
31733       {
31734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31735       };
31736     } catch (Dali::DaliException e) {
31737       {
31738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31739       };
31740     } catch (...) {
31741       {
31742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31743       };
31744     }
31745   }
31746
31747   jresult = (void *)result;
31748   return jresult;
31749 }
31750
31751
31752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31753   void * jresult ;
31754   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31755   Dali::LongPressGesture *arg2 = 0 ;
31756   Dali::LongPressGesture *result = 0 ;
31757
31758   arg1 = (Dali::LongPressGesture *)jarg1;
31759   arg2 = (Dali::LongPressGesture *)jarg2;
31760   if (!arg2) {
31761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31762     return 0;
31763   }
31764   {
31765     try {
31766       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31767     } catch (std::out_of_range& e) {
31768       {
31769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31770       };
31771     } catch (std::exception& e) {
31772       {
31773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31774       };
31775     } catch (Dali::DaliException e) {
31776       {
31777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31778       };
31779     } catch (...) {
31780       {
31781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31782       };
31783     }
31784   }
31785
31786   jresult = (void *)result;
31787   return jresult;
31788 }
31789
31790
31791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31792   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31793
31794   arg1 = (Dali::LongPressGesture *)jarg1;
31795   {
31796     try {
31797       delete arg1;
31798     } catch (std::out_of_range& e) {
31799       {
31800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31801       };
31802     } catch (std::exception& e) {
31803       {
31804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31805       };
31806     } catch (Dali::DaliException e) {
31807       {
31808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31809       };
31810     } catch (...) {
31811       {
31812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31813       };
31814     }
31815   }
31816
31817 }
31818
31819
31820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31821   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31822   unsigned int arg2 ;
31823
31824   arg1 = (Dali::LongPressGesture *)jarg1;
31825   arg2 = (unsigned int)jarg2;
31826   if (arg1) (arg1)->numberOfTouches = arg2;
31827 }
31828
31829
31830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31831   unsigned int jresult ;
31832   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31833   unsigned int result;
31834
31835   arg1 = (Dali::LongPressGesture *)jarg1;
31836   result = (unsigned int) ((arg1)->numberOfTouches);
31837   jresult = result;
31838   return jresult;
31839 }
31840
31841
31842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31843   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31844   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31845
31846   arg1 = (Dali::LongPressGesture *)jarg1;
31847   arg2 = (Dali::Vector2 *)jarg2;
31848   if (arg1) (arg1)->screenPoint = *arg2;
31849 }
31850
31851
31852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31853   void * jresult ;
31854   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31855   Dali::Vector2 *result = 0 ;
31856
31857   arg1 = (Dali::LongPressGesture *)jarg1;
31858   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
31859   jresult = (void *)result;
31860   return jresult;
31861 }
31862
31863
31864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
31865   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31866   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31867
31868   arg1 = (Dali::LongPressGesture *)jarg1;
31869   arg2 = (Dali::Vector2 *)jarg2;
31870   if (arg1) (arg1)->localPoint = *arg2;
31871 }
31872
31873
31874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
31875   void * jresult ;
31876   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31877   Dali::Vector2 *result = 0 ;
31878
31879   arg1 = (Dali::LongPressGesture *)jarg1;
31880   result = (Dali::Vector2 *)& ((arg1)->localPoint);
31881   jresult = (void *)result;
31882   return jresult;
31883 }
31884
31885
31886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
31887   void * jresult ;
31888   Dali::WheelEvent *result = 0 ;
31889
31890   {
31891     try {
31892       result = (Dali::WheelEvent *)new Dali::WheelEvent();
31893     } catch (std::out_of_range& e) {
31894       {
31895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31896       };
31897     } catch (std::exception& e) {
31898       {
31899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (Dali::DaliException e) {
31902       {
31903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31904       };
31905     } catch (...) {
31906       {
31907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31908       };
31909     }
31910   }
31911
31912   jresult = (void *)result;
31913   return jresult;
31914 }
31915
31916
31917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
31918   void * jresult ;
31919   Dali::WheelEvent::Type arg1 ;
31920   int arg2 ;
31921   unsigned int arg3 ;
31922   Dali::Vector2 arg4 ;
31923   int arg5 ;
31924   unsigned int arg6 ;
31925   Dali::Vector2 *argp4 ;
31926   Dali::WheelEvent *result = 0 ;
31927
31928   arg1 = (Dali::WheelEvent::Type)jarg1;
31929   arg2 = (int)jarg2;
31930   arg3 = (unsigned int)jarg3;
31931   argp4 = (Dali::Vector2 *)jarg4;
31932   if (!argp4) {
31933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
31934     return 0;
31935   }
31936   arg4 = *argp4;
31937   arg5 = (int)jarg5;
31938   arg6 = (unsigned int)jarg6;
31939   {
31940     try {
31941       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
31942     } catch (std::out_of_range& e) {
31943       {
31944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31945       };
31946     } catch (std::exception& e) {
31947       {
31948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31949       };
31950     } catch (Dali::DaliException e) {
31951       {
31952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31953       };
31954     } catch (...) {
31955       {
31956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31957       };
31958     }
31959   }
31960
31961   jresult = (void *)result;
31962   return jresult;
31963 }
31964
31965
31966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
31967   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
31968
31969   arg1 = (Dali::WheelEvent *)jarg1;
31970   {
31971     try {
31972       delete arg1;
31973     } catch (std::out_of_range& e) {
31974       {
31975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31976       };
31977     } catch (std::exception& e) {
31978       {
31979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31980       };
31981     } catch (Dali::DaliException e) {
31982       {
31983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31984       };
31985     } catch (...) {
31986       {
31987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31988       };
31989     }
31990   }
31991
31992 }
31993
31994
31995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
31996   unsigned int jresult ;
31997   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
31998   bool result;
31999
32000   arg1 = (Dali::WheelEvent *)jarg1;
32001   {
32002     try {
32003       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32004     } catch (std::out_of_range& e) {
32005       {
32006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32007       };
32008     } catch (std::exception& e) {
32009       {
32010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32011       };
32012     } catch (Dali::DaliException e) {
32013       {
32014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32015       };
32016     } catch (...) {
32017       {
32018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32019       };
32020     }
32021   }
32022
32023   jresult = result;
32024   return jresult;
32025 }
32026
32027
32028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32029   unsigned int jresult ;
32030   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32031   bool result;
32032
32033   arg1 = (Dali::WheelEvent *)jarg1;
32034   {
32035     try {
32036       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32037     } catch (std::out_of_range& e) {
32038       {
32039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32040       };
32041     } catch (std::exception& e) {
32042       {
32043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32044       };
32045     } catch (Dali::DaliException e) {
32046       {
32047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32048       };
32049     } catch (...) {
32050       {
32051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32052       };
32053     }
32054   }
32055
32056   jresult = result;
32057   return jresult;
32058 }
32059
32060
32061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32062   unsigned int jresult ;
32063   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32064   bool result;
32065
32066   arg1 = (Dali::WheelEvent *)jarg1;
32067   {
32068     try {
32069       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32070     } catch (std::out_of_range& e) {
32071       {
32072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32073       };
32074     } catch (std::exception& e) {
32075       {
32076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32077       };
32078     } catch (Dali::DaliException e) {
32079       {
32080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32081       };
32082     } catch (...) {
32083       {
32084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32085       };
32086     }
32087   }
32088
32089   jresult = result;
32090   return jresult;
32091 }
32092
32093
32094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32095   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32096   Dali::WheelEvent::Type arg2 ;
32097
32098   arg1 = (Dali::WheelEvent *)jarg1;
32099   arg2 = (Dali::WheelEvent::Type)jarg2;
32100   if (arg1) (arg1)->type = arg2;
32101 }
32102
32103
32104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32105   int jresult ;
32106   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32107   Dali::WheelEvent::Type result;
32108
32109   arg1 = (Dali::WheelEvent *)jarg1;
32110   result = (Dali::WheelEvent::Type) ((arg1)->type);
32111   jresult = (int)result;
32112   return jresult;
32113 }
32114
32115
32116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32117   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32118   int arg2 ;
32119
32120   arg1 = (Dali::WheelEvent *)jarg1;
32121   arg2 = (int)jarg2;
32122   if (arg1) (arg1)->direction = arg2;
32123 }
32124
32125
32126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32127   int jresult ;
32128   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32129   int result;
32130
32131   arg1 = (Dali::WheelEvent *)jarg1;
32132   result = (int) ((arg1)->direction);
32133   jresult = result;
32134   return jresult;
32135 }
32136
32137
32138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32139   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32140   unsigned int arg2 ;
32141
32142   arg1 = (Dali::WheelEvent *)jarg1;
32143   arg2 = (unsigned int)jarg2;
32144   if (arg1) (arg1)->modifiers = arg2;
32145 }
32146
32147
32148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32149   unsigned int jresult ;
32150   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32151   unsigned int result;
32152
32153   arg1 = (Dali::WheelEvent *)jarg1;
32154   result = (unsigned int) ((arg1)->modifiers);
32155   jresult = result;
32156   return jresult;
32157 }
32158
32159
32160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32161   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32162   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32163
32164   arg1 = (Dali::WheelEvent *)jarg1;
32165   arg2 = (Dali::Vector2 *)jarg2;
32166   if (arg1) (arg1)->point = *arg2;
32167 }
32168
32169
32170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32171   void * jresult ;
32172   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32173   Dali::Vector2 *result = 0 ;
32174
32175   arg1 = (Dali::WheelEvent *)jarg1;
32176   result = (Dali::Vector2 *)& ((arg1)->point);
32177   jresult = (void *)result;
32178   return jresult;
32179 }
32180
32181
32182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32183   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32184   int arg2 ;
32185
32186   arg1 = (Dali::WheelEvent *)jarg1;
32187   arg2 = (int)jarg2;
32188   if (arg1) (arg1)->z = arg2;
32189 }
32190
32191
32192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32193   int jresult ;
32194   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32195   int result;
32196
32197   arg1 = (Dali::WheelEvent *)jarg1;
32198   result = (int) ((arg1)->z);
32199   jresult = result;
32200   return jresult;
32201 }
32202
32203
32204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32205   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32206   unsigned int arg2 ;
32207
32208   arg1 = (Dali::WheelEvent *)jarg1;
32209   arg2 = (unsigned int)jarg2;
32210   if (arg1) (arg1)->timeStamp = arg2;
32211 }
32212
32213
32214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32215   unsigned int jresult ;
32216   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32217   unsigned int result;
32218
32219   arg1 = (Dali::WheelEvent *)jarg1;
32220   result = (unsigned int) ((arg1)->timeStamp);
32221   jresult = result;
32222   return jresult;
32223 }
32224
32225 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32226   char * jresult ;
32227   Dali::KeyEvent *arg1 = 0 ;
32228   std::string result;
32229
32230   arg1 = (Dali::KeyEvent *)jarg1;
32231   if (!arg1) {
32232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32233     return 0;
32234   }
32235   {
32236     try {
32237       result = arg1->GetDeviceName();
32238     } catch (std::out_of_range& e) {
32239       {
32240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32241       };
32242     } catch (std::exception& e) {
32243       {
32244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32245       };
32246     } catch (Dali::DaliException e) {
32247       {
32248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32249       };
32250     } catch (...) {
32251       {
32252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32253       };
32254     }
32255   }
32256
32257   jresult = SWIG_csharp_string_callback((&result)->c_str());
32258   return jresult;
32259 }
32260
32261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32262   int jresult ;
32263   Dali::KeyEvent *arg1 = 0 ;
32264   Dali::Device::Class::Type result;
32265
32266   arg1 = (Dali::KeyEvent *)jarg1;
32267   if (!arg1) {
32268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32269     return 0;
32270   }
32271   {
32272     try {
32273       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32274     } catch (std::out_of_range& e) {
32275       {
32276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32277       };
32278     } catch (std::exception& e) {
32279       {
32280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32281       };
32282     } catch (Dali::DaliException e) {
32283       {
32284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32285       };
32286     } catch (...) {
32287       {
32288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32289       };
32290     }
32291   }
32292
32293   jresult = (int)result;
32294   return jresult;
32295 }
32296
32297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32298   int jresult ;
32299   Dali::KeyEvent *arg1 = 0 ;
32300   Dali::Device::Subclass::Type result;
32301
32302   arg1 = (Dali::KeyEvent *)jarg1;
32303   if (!arg1) {
32304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32305     return 0;
32306   }
32307   {
32308     try {
32309       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32310     } catch (std::out_of_range& e) {
32311       {
32312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32313       };
32314     } catch (std::exception& e) {
32315       {
32316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32317       };
32318     } catch (Dali::DaliException e) {
32319       {
32320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32321       };
32322     } catch (...) {
32323       {
32324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32325       };
32326     }
32327   }
32328
32329   jresult = (int)result;
32330   return jresult;
32331 }
32332
32333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32334   Dali::Actor arg1 ;
32335   Dali::Actor *argp1 ;
32336
32337   argp1 = (Dali::Actor *)jarg1;
32338   if (!argp1) {
32339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32340     return ;
32341   }
32342   arg1 = *argp1;
32343   {
32344     try {
32345       arg1.Raise();
32346     } catch (std::out_of_range& e) {
32347       {
32348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32349       };
32350     } catch (std::exception& e) {
32351       {
32352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32353       };
32354     } catch (Dali::DaliException e) {
32355       {
32356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32357       };
32358     } catch (...) {
32359       {
32360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32361       };
32362     }
32363   }
32364
32365 }
32366
32367
32368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32369   Dali::Actor arg1 ;
32370   Dali::Actor *argp1 ;
32371
32372   argp1 = (Dali::Actor *)jarg1;
32373   if (!argp1) {
32374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32375     return ;
32376   }
32377   arg1 = *argp1;
32378   {
32379     try {
32380       arg1.Lower();
32381     } catch (std::out_of_range& e) {
32382       {
32383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32384       };
32385     } catch (std::exception& e) {
32386       {
32387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32388       };
32389     } catch (Dali::DaliException e) {
32390       {
32391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32392       };
32393     } catch (...) {
32394       {
32395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32396       };
32397     }
32398   }
32399
32400 }
32401
32402
32403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32404   Dali::Actor arg1 ;
32405   Dali::Actor *argp1 ;
32406
32407   argp1 = (Dali::Actor *)jarg1;
32408   if (!argp1) {
32409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32410     return ;
32411   }
32412   arg1 = *argp1;
32413   {
32414     try {
32415       arg1.RaiseToTop();
32416     } catch (std::out_of_range& e) {
32417       {
32418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32419       };
32420     } catch (std::exception& e) {
32421       {
32422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32423       };
32424     } catch (Dali::DaliException e) {
32425       {
32426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32427       };
32428     } catch (...) {
32429       {
32430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32431       };
32432     }
32433   }
32434
32435 }
32436
32437
32438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32439   Dali::Actor arg1 ;
32440   Dali::Actor *argp1 ;
32441
32442   argp1 = (Dali::Actor *)jarg1;
32443   if (!argp1) {
32444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32445     return ;
32446   }
32447   arg1 = *argp1;
32448   {
32449     try {
32450       arg1.LowerToBottom();
32451     } catch (std::out_of_range& e) {
32452       {
32453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32454       };
32455     } catch (std::exception& e) {
32456       {
32457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32458       };
32459     } catch (Dali::DaliException e) {
32460       {
32461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32462       };
32463     } catch (...) {
32464       {
32465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32466       };
32467     }
32468   }
32469
32470 }
32471
32472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32473   Dali::Actor arg1 ;
32474   Dali::Actor arg2 ;
32475   Dali::Actor *argp1 ;
32476   Dali::Actor *argp2 ;
32477
32478   argp1 = (Dali::Actor *)jarg1;
32479   if (!argp1) {
32480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32481     return ;
32482   }
32483   arg1 = *argp1;
32484   argp2 = (Dali::Actor *)jarg2;
32485   if (!argp2) {
32486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32487     return ;
32488   }
32489   arg2 = *argp2;
32490   {
32491     try {
32492       arg1.RaiseAbove(arg2);
32493     } catch (std::out_of_range& e) {
32494       {
32495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32496       };
32497     } catch (std::exception& e) {
32498       {
32499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32500       };
32501     } catch (Dali::DaliException e) {
32502       {
32503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32504       };
32505     } catch (...) {
32506       {
32507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32508       };
32509     }
32510   }
32511
32512 }
32513
32514
32515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32516   Dali::Actor arg1 ;
32517   Dali::Actor arg2 ;
32518   Dali::Actor *argp1 ;
32519   Dali::Actor *argp2 ;
32520
32521   argp1 = (Dali::Actor *)jarg1;
32522   if (!argp1) {
32523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32524     return ;
32525   }
32526   arg1 = *argp1;
32527   argp2 = (Dali::Actor *)jarg2;
32528   if (!argp2) {
32529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32530     return ;
32531   }
32532   arg2 = *argp2;
32533   {
32534     try {
32535       arg1.LowerBelow(arg2);
32536     } catch (std::out_of_range& e) {
32537       {
32538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32539       };
32540     } catch (std::exception& e) {
32541       {
32542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32543       };
32544     } catch (Dali::DaliException e) {
32545       {
32546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32547       };
32548     } catch (...) {
32549       {
32550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32551       };
32552     }
32553   }
32554
32555 }
32556
32557
32558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32559   void * jresult ;
32560   Dali::Actor arg1 ;
32561   Dali::Actor *argp1 ;
32562   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32563
32564   argp1 = (Dali::Actor *)jarg1;
32565   if (!argp1) {
32566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32567     return 0;
32568   }
32569   arg1 = *argp1;
32570   {
32571     try {
32572       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32573     } catch (std::out_of_range& e) {
32574       {
32575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32576       };
32577     } catch (std::exception& e) {
32578       {
32579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32580       };
32581     } catch (Dali::DaliException e) {
32582       {
32583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32584       };
32585     } catch (...) {
32586       {
32587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32588       };
32589     }
32590   }
32591
32592   jresult = (void *)result;
32593   return jresult;
32594 }
32595
32596
32597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32598   void * jresult ;
32599   Dali::Actor *arg1 ;
32600   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32601
32602   arg1 = (Dali::Actor *)jarg1;
32603   {
32604     try {
32605       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32606     } catch (std::out_of_range& e) {
32607       {
32608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32609       };
32610     } catch (std::exception& e) {
32611       {
32612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32613       };
32614     } catch (Dali::DaliException e) {
32615       {
32616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32617       };
32618     } catch (...) {
32619       {
32620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32621       };
32622     }
32623   }
32624
32625   jresult = (void *)result;
32626   return jresult;
32627 }
32628
32629
32630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32631   int jresult ;
32632   int result;
32633
32634   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32635   jresult = (int)result;
32636   return jresult;
32637 }
32638
32639
32640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32641   int jresult ;
32642   int result;
32643
32644   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32645   jresult = (int)result;
32646   return jresult;
32647 }
32648
32649
32650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32651   int jresult ;
32652   int result;
32653
32654   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32655   jresult = (int)result;
32656   return jresult;
32657 }
32658
32659
32660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32661   int jresult ;
32662   int result;
32663
32664   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32665   jresult = (int)result;
32666   return jresult;
32667 }
32668
32669
32670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32671   int jresult ;
32672   int result;
32673
32674   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32675   jresult = (int)result;
32676   return jresult;
32677 }
32678
32679
32680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32681   int jresult ;
32682   int result;
32683
32684   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32685   jresult = (int)result;
32686   return jresult;
32687 }
32688
32689
32690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32691   int jresult ;
32692   int result;
32693
32694   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32695   jresult = (int)result;
32696   return jresult;
32697 }
32698
32699
32700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32701   int jresult ;
32702   int result;
32703
32704   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32705   jresult = (int)result;
32706   return jresult;
32707 }
32708
32709
32710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32711   int jresult ;
32712   int result;
32713
32714   result = (int)Dali::Actor::Property::SIZE;
32715   jresult = (int)result;
32716   return jresult;
32717 }
32718
32719
32720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32721   int jresult ;
32722   int result;
32723
32724   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32725   jresult = (int)result;
32726   return jresult;
32727 }
32728
32729
32730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32731   int jresult ;
32732   int result;
32733
32734   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32735   jresult = (int)result;
32736   return jresult;
32737 }
32738
32739
32740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32741   int jresult ;
32742   int result;
32743
32744   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32745   jresult = (int)result;
32746   return jresult;
32747 }
32748
32749
32750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32751   int jresult ;
32752   int result;
32753
32754   result = (int)Dali::Actor::Property::POSITION;
32755   jresult = (int)result;
32756   return jresult;
32757 }
32758
32759
32760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32761   int jresult ;
32762   int result;
32763
32764   result = (int)Dali::Actor::Property::POSITION_X;
32765   jresult = (int)result;
32766   return jresult;
32767 }
32768
32769
32770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32771   int jresult ;
32772   int result;
32773
32774   result = (int)Dali::Actor::Property::POSITION_Y;
32775   jresult = (int)result;
32776   return jresult;
32777 }
32778
32779
32780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32781   int jresult ;
32782   int result;
32783
32784   result = (int)Dali::Actor::Property::POSITION_Z;
32785   jresult = (int)result;
32786   return jresult;
32787 }
32788
32789
32790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32791   int jresult ;
32792   int result;
32793
32794   result = (int)Dali::Actor::Property::WORLD_POSITION;
32795   jresult = (int)result;
32796   return jresult;
32797 }
32798
32799
32800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32801   int jresult ;
32802   int result;
32803
32804   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32805   jresult = (int)result;
32806   return jresult;
32807 }
32808
32809
32810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32811   int jresult ;
32812   int result;
32813
32814   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32815   jresult = (int)result;
32816   return jresult;
32817 }
32818
32819
32820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32821   int jresult ;
32822   int result;
32823
32824   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32825   jresult = (int)result;
32826   return jresult;
32827 }
32828
32829
32830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32831   int jresult ;
32832   int result;
32833
32834   result = (int)Dali::Actor::Property::ORIENTATION;
32835   jresult = (int)result;
32836   return jresult;
32837 }
32838
32839
32840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32841   int jresult ;
32842   int result;
32843
32844   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32845   jresult = (int)result;
32846   return jresult;
32847 }
32848
32849
32850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32851   int jresult ;
32852   int result;
32853
32854   result = (int)Dali::Actor::Property::SCALE;
32855   jresult = (int)result;
32856   return jresult;
32857 }
32858
32859
32860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
32861   int jresult ;
32862   int result;
32863
32864   result = (int)Dali::Actor::Property::SCALE_X;
32865   jresult = (int)result;
32866   return jresult;
32867 }
32868
32869
32870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
32871   int jresult ;
32872   int result;
32873
32874   result = (int)Dali::Actor::Property::SCALE_Y;
32875   jresult = (int)result;
32876   return jresult;
32877 }
32878
32879
32880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
32881   int jresult ;
32882   int result;
32883
32884   result = (int)Dali::Actor::Property::SCALE_Z;
32885   jresult = (int)result;
32886   return jresult;
32887 }
32888
32889
32890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
32891   int jresult ;
32892   int result;
32893
32894   result = (int)Dali::Actor::Property::WORLD_SCALE;
32895   jresult = (int)result;
32896   return jresult;
32897 }
32898
32899
32900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
32901   int jresult ;
32902   int result;
32903
32904   result = (int)Dali::Actor::Property::VISIBLE;
32905   jresult = (int)result;
32906   return jresult;
32907 }
32908
32909
32910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
32911   int jresult ;
32912   int result;
32913
32914   result = (int)Dali::Actor::Property::COLOR;
32915   jresult = (int)result;
32916   return jresult;
32917 }
32918
32919
32920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
32921   int jresult ;
32922   int result;
32923
32924   result = (int)Dali::Actor::Property::COLOR_RED;
32925   jresult = (int)result;
32926   return jresult;
32927 }
32928
32929
32930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
32931   int jresult ;
32932   int result;
32933
32934   result = (int)Dali::Actor::Property::COLOR_GREEN;
32935   jresult = (int)result;
32936   return jresult;
32937 }
32938
32939
32940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
32941   int jresult ;
32942   int result;
32943
32944   result = (int)Dali::Actor::Property::COLOR_BLUE;
32945   jresult = (int)result;
32946   return jresult;
32947 }
32948
32949
32950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
32951   int jresult ;
32952   int result;
32953
32954   result = (int)Dali::Actor::Property::COLOR_ALPHA;
32955   jresult = (int)result;
32956   return jresult;
32957 }
32958
32959
32960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
32961   int jresult ;
32962   int result;
32963
32964   result = (int)Dali::Actor::Property::WORLD_COLOR;
32965   jresult = (int)result;
32966   return jresult;
32967 }
32968
32969
32970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
32971   int jresult ;
32972   int result;
32973
32974   result = (int)Dali::Actor::Property::WORLD_MATRIX;
32975   jresult = (int)result;
32976   return jresult;
32977 }
32978
32979
32980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
32981   int jresult ;
32982   int result;
32983
32984   result = (int)Dali::Actor::Property::NAME;
32985   jresult = (int)result;
32986   return jresult;
32987 }
32988
32989
32990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
32991   int jresult ;
32992   int result;
32993
32994   result = (int)Dali::Actor::Property::SENSITIVE;
32995   jresult = (int)result;
32996   return jresult;
32997 }
32998
32999
33000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33001   int jresult ;
33002   int result;
33003
33004   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33005   jresult = (int)result;
33006   return jresult;
33007 }
33008
33009
33010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33011   int jresult ;
33012   int result;
33013
33014   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33015   jresult = (int)result;
33016   return jresult;
33017 }
33018
33019
33020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33021   int jresult ;
33022   int result;
33023
33024   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33025   jresult = (int)result;
33026   return jresult;
33027 }
33028
33029
33030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33031   int jresult ;
33032   int result;
33033
33034   result = (int)Dali::Actor::Property::COLOR_MODE;
33035   jresult = (int)result;
33036   return jresult;
33037 }
33038
33039
33040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33041   int jresult ;
33042   int result;
33043
33044   result = (int)Dali::Actor::Property::DRAW_MODE;
33045   jresult = (int)result;
33046   return jresult;
33047 }
33048
33049
33050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33051   int jresult ;
33052   int result;
33053
33054   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33055   jresult = (int)result;
33056   return jresult;
33057 }
33058
33059
33060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33061   int jresult ;
33062   int result;
33063
33064   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33065   jresult = (int)result;
33066   return jresult;
33067 }
33068
33069
33070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33071   int jresult ;
33072   int result;
33073
33074   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33075   jresult = (int)result;
33076   return jresult;
33077 }
33078
33079
33080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33081   int jresult ;
33082   int result;
33083
33084   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33085   jresult = (int)result;
33086   return jresult;
33087 }
33088
33089
33090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33091   int jresult ;
33092   int result;
33093
33094   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33095   jresult = (int)result;
33096   return jresult;
33097 }
33098
33099
33100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33101   int jresult ;
33102   int result;
33103
33104   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33105   jresult = (int)result;
33106   return jresult;
33107 }
33108
33109
33110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33111   int jresult ;
33112   int result;
33113
33114   result = (int)Dali::Actor::Property::PADDING;
33115   jresult = (int)result;
33116   return jresult;
33117 }
33118
33119
33120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33121   int jresult ;
33122   int result;
33123
33124   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33125   jresult = (int)result;
33126   return jresult;
33127 }
33128
33129
33130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33131   int jresult ;
33132   int result;
33133
33134   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33135   jresult = (int)result;
33136   return jresult;
33137 }
33138
33139
33140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33141   int jresult ;
33142   int result;
33143
33144   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33145   jresult = (int)result;
33146   return jresult;
33147 }
33148
33149
33150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33151   int jresult ;
33152   int result;
33153
33154   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33155   jresult = (int)result;
33156   return jresult;
33157 }
33158
33159 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33160
33161   return Dali::Actor::Property::OPACITY;
33162 }
33163
33164 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33165
33166   return Dali::Actor::Property::SCREEN_POSITION;
33167 }
33168
33169 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33170
33171   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33172 }
33173
33174 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33175   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33176 }
33177
33178 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33179   return Dali::Actor::Property::LAYOUT_DIRECTION;
33180 }
33181
33182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33183   void * jresult ;
33184   Dali::Actor::Property *result = 0 ;
33185
33186   {
33187     try {
33188       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33189     } catch (std::out_of_range& e) {
33190       {
33191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33192       };
33193     } catch (std::exception& e) {
33194       {
33195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33196       };
33197     } catch (Dali::DaliException e) {
33198       {
33199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33200       };
33201     } catch (...) {
33202       {
33203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33204       };
33205     }
33206   }
33207
33208   jresult = (void *)result;
33209   return jresult;
33210 }
33211
33212
33213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33214   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33215
33216   arg1 = (Dali::Actor::Property *)jarg1;
33217   {
33218     try {
33219       delete arg1;
33220     } catch (std::out_of_range& e) {
33221       {
33222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33223       };
33224     } catch (std::exception& e) {
33225       {
33226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33227       };
33228     } catch (Dali::DaliException e) {
33229       {
33230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33231       };
33232     } catch (...) {
33233       {
33234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33235       };
33236     }
33237   }
33238
33239 }
33240
33241
33242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33243   void * jresult ;
33244   Dali::Actor *result = 0 ;
33245
33246   {
33247     try {
33248       result = (Dali::Actor *)new Dali::Actor();
33249     } catch (std::out_of_range& e) {
33250       {
33251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33252       };
33253     } catch (std::exception& e) {
33254       {
33255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33256       };
33257     } catch (Dali::DaliException e) {
33258       {
33259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33260       };
33261     } catch (...) {
33262       {
33263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33264       };
33265     }
33266   }
33267
33268   jresult = (void *)result;
33269   return jresult;
33270 }
33271
33272
33273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33274   void * jresult ;
33275   Dali::Actor result;
33276
33277   {
33278     try {
33279       result = Dali::Actor::New();
33280     } catch (std::out_of_range& e) {
33281       {
33282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33283       };
33284     } catch (std::exception& e) {
33285       {
33286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33287       };
33288     } catch (Dali::DaliException e) {
33289       {
33290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33291       };
33292     } catch (...) {
33293       {
33294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33295       };
33296     }
33297   }
33298
33299   jresult = new Dali::Actor((const Dali::Actor &)result);
33300   return jresult;
33301 }
33302
33303
33304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33305   void * jresult ;
33306   Dali::BaseHandle arg1 ;
33307   Dali::BaseHandle *argp1 ;
33308   Dali::Actor result;
33309
33310   argp1 = (Dali::BaseHandle *)jarg1;
33311   if (!argp1) {
33312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33313     return 0;
33314   }
33315   arg1 = *argp1;
33316   {
33317     try {
33318       result = Dali::Actor::DownCast(arg1);
33319     } catch (std::out_of_range& e) {
33320       {
33321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33322       };
33323     } catch (std::exception& e) {
33324       {
33325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33326       };
33327     } catch (Dali::DaliException e) {
33328       {
33329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33330       };
33331     } catch (...) {
33332       {
33333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33334       };
33335     }
33336   }
33337
33338   jresult = new Dali::Actor((const Dali::Actor &)result);
33339   return jresult;
33340 }
33341
33342
33343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33344   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33345
33346   arg1 = (Dali::Actor *)jarg1;
33347   {
33348     try {
33349       delete arg1;
33350     } catch (std::out_of_range& e) {
33351       {
33352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33353       };
33354     } catch (std::exception& e) {
33355       {
33356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33357       };
33358     } catch (Dali::DaliException e) {
33359       {
33360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33361       };
33362     } catch (...) {
33363       {
33364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33365       };
33366     }
33367   }
33368
33369 }
33370
33371
33372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33373   void * jresult ;
33374   Dali::Actor *arg1 = 0 ;
33375   Dali::Actor *result = 0 ;
33376
33377   arg1 = (Dali::Actor *)jarg1;
33378   if (!arg1) {
33379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33380     return 0;
33381   }
33382   {
33383     try {
33384       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33385     } catch (std::out_of_range& e) {
33386       {
33387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33388       };
33389     } catch (std::exception& e) {
33390       {
33391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33392       };
33393     } catch (Dali::DaliException e) {
33394       {
33395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33396       };
33397     } catch (...) {
33398       {
33399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33400       };
33401     }
33402   }
33403
33404   jresult = (void *)result;
33405   return jresult;
33406 }
33407
33408
33409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33410   void * jresult ;
33411   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33412   Dali::Actor *arg2 = 0 ;
33413   Dali::Actor *result = 0 ;
33414
33415   arg1 = (Dali::Actor *)jarg1;
33416   arg2 = (Dali::Actor *)jarg2;
33417   if (!arg2) {
33418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33419     return 0;
33420   }
33421   {
33422     try {
33423       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33424     } catch (std::out_of_range& e) {
33425       {
33426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33427       };
33428     } catch (std::exception& e) {
33429       {
33430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33431       };
33432     } catch (Dali::DaliException e) {
33433       {
33434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33435       };
33436     } catch (...) {
33437       {
33438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33439       };
33440     }
33441   }
33442
33443   jresult = (void *)result;
33444   return jresult;
33445 }
33446
33447
33448 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33449   char * jresult ;
33450   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33451   std::string *result = 0 ;
33452
33453   arg1 = (Dali::Actor *)jarg1;
33454   {
33455     try {
33456       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33457       result = (std::string *) &name;
33458     } catch (std::out_of_range& e) {
33459       {
33460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33461       };
33462     } catch (std::exception& e) {
33463       {
33464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33465       };
33466     } catch (Dali::DaliException e) {
33467       {
33468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33469       };
33470     } catch (...) {
33471       {
33472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33473       };
33474     }
33475   }
33476
33477   jresult = SWIG_csharp_string_callback(result->c_str());
33478   return jresult;
33479 }
33480
33481
33482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33483   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33484   std::string *arg2 = 0 ;
33485
33486   arg1 = (Dali::Actor *)jarg1;
33487   if (!jarg2) {
33488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33489     return ;
33490   }
33491   std::string arg2_str(jarg2);
33492   arg2 = &arg2_str;
33493   {
33494     try {
33495       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33496     } catch (std::out_of_range& e) {
33497       {
33498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33499       };
33500     } catch (std::exception& e) {
33501       {
33502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33503       };
33504     } catch (Dali::DaliException e) {
33505       {
33506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33507       };
33508     } catch (...) {
33509       {
33510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33511       };
33512     }
33513   }
33514
33515
33516   //argout typemap for const std::string&
33517
33518 }
33519
33520
33521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33522   unsigned int jresult ;
33523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33524   unsigned int result;
33525
33526   arg1 = (Dali::Actor *)jarg1;
33527
33528   if(!arg1) {
33529     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33530     return -1;
33531   }
33532
33533   {
33534     try {
33535       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33536     } catch (std::out_of_range& e) {
33537       {
33538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33539       };
33540     } catch (std::exception& e) {
33541       {
33542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33543       };
33544     } catch (Dali::DaliException e) {
33545       {
33546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33547       };
33548     } catch (...) {
33549       {
33550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33551       };
33552     }
33553   }
33554
33555   jresult = result;
33556   return jresult;
33557 }
33558
33559
33560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33561   unsigned int jresult ;
33562   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33563   bool result;
33564
33565   arg1 = (Dali::Actor *)jarg1;
33566   {
33567     try {
33568       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33569     } catch (std::out_of_range& e) {
33570       {
33571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33572       };
33573     } catch (std::exception& e) {
33574       {
33575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33576       };
33577     } catch (Dali::DaliException e) {
33578       {
33579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33580       };
33581     } catch (...) {
33582       {
33583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33584       };
33585     }
33586   }
33587
33588   jresult = result;
33589   return jresult;
33590 }
33591
33592
33593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33594   unsigned int jresult ;
33595   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33596   bool result;
33597
33598   arg1 = (Dali::Actor *)jarg1;
33599   {
33600     try {
33601       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
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 = result;
33622   return jresult;
33623 }
33624
33625
33626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33627   unsigned int jresult ;
33628   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33629   bool result;
33630
33631   arg1 = (Dali::Actor *)jarg1;
33632   {
33633     try {
33634       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33635     } catch (std::out_of_range& e) {
33636       {
33637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33638       };
33639     } catch (std::exception& e) {
33640       {
33641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33642       };
33643     } catch (Dali::DaliException e) {
33644       {
33645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33646       };
33647     } catch (...) {
33648       {
33649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33650       };
33651     }
33652   }
33653
33654   jresult = result;
33655   return jresult;
33656 }
33657
33658
33659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33660   void * jresult ;
33661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33662   Dali::Layer result;
33663
33664   arg1 = (Dali::Actor *)jarg1;
33665   {
33666     try {
33667       result = (arg1)->GetLayer();
33668     } catch (std::out_of_range& e) {
33669       {
33670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33671       };
33672     } catch (std::exception& e) {
33673       {
33674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33675       };
33676     } catch (Dali::DaliException e) {
33677       {
33678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33679       };
33680     } catch (...) {
33681       {
33682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33683       };
33684     }
33685   }
33686
33687   jresult = new Dali::Layer((const Dali::Layer &)result);
33688   return jresult;
33689 }
33690
33691
33692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33693   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33694   Dali::Actor arg2 ;
33695   Dali::Actor *argp2 ;
33696
33697   arg1 = (Dali::Actor *)jarg1;
33698   argp2 = (Dali::Actor *)jarg2;
33699   if (!argp2) {
33700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33701     return ;
33702   }
33703   arg2 = *argp2;
33704   {
33705     try {
33706       (arg1)->Add(arg2);
33707     } catch (std::out_of_range& e) {
33708       {
33709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33710       };
33711     } catch (std::exception& e) {
33712       {
33713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33714       };
33715     } catch (Dali::DaliException e) {
33716       {
33717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33718       };
33719     } catch (...) {
33720       {
33721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33722       };
33723     }
33724   }
33725
33726 }
33727
33728
33729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33730   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33731   Dali::Actor arg2 ;
33732   Dali::Actor *argp2 ;
33733
33734   arg1 = (Dali::Actor *)jarg1;
33735   argp2 = (Dali::Actor *)jarg2;
33736   if (!argp2) {
33737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33738     return ;
33739   }
33740   arg2 = *argp2;
33741   {
33742     try {
33743       (arg1)->Remove(arg2);
33744     } catch (std::out_of_range& e) {
33745       {
33746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33747       };
33748     } catch (std::exception& e) {
33749       {
33750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33751       };
33752     } catch (Dali::DaliException e) {
33753       {
33754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33755       };
33756     } catch (...) {
33757       {
33758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33759       };
33760     }
33761   }
33762
33763 }
33764
33765
33766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33767   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33768
33769   arg1 = (Dali::Actor *)jarg1;
33770   {
33771     try {
33772       (arg1)->Unparent();
33773     } catch (std::out_of_range& e) {
33774       {
33775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33776       };
33777     } catch (std::exception& e) {
33778       {
33779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33780       };
33781     } catch (Dali::DaliException e) {
33782       {
33783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33784       };
33785     } catch (...) {
33786       {
33787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33788       };
33789     }
33790   }
33791
33792 }
33793
33794
33795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33796   unsigned int jresult ;
33797   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33798   unsigned int result;
33799
33800   arg1 = (Dali::Actor *)jarg1;
33801   {
33802     try {
33803       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33804     } catch (std::out_of_range& e) {
33805       {
33806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33807       };
33808     } catch (std::exception& e) {
33809       {
33810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33811       };
33812     } catch (Dali::DaliException e) {
33813       {
33814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33815       };
33816     } catch (...) {
33817       {
33818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33819       };
33820     }
33821   }
33822
33823   jresult = result;
33824   return jresult;
33825 }
33826
33827
33828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33829   void * jresult ;
33830   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33831   unsigned int arg2 ;
33832   Dali::Actor result;
33833
33834   arg1 = (Dali::Actor *)jarg1;
33835   arg2 = (unsigned int)jarg2;
33836   {
33837     try {
33838       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33839     } catch (std::out_of_range& e) {
33840       {
33841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33842       };
33843     } catch (std::exception& e) {
33844       {
33845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33846       };
33847     } catch (Dali::DaliException e) {
33848       {
33849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33850       };
33851     } catch (...) {
33852       {
33853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33854       };
33855     }
33856   }
33857
33858   jresult = new Dali::Actor((const Dali::Actor &)result);
33859   return jresult;
33860 }
33861
33862
33863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
33864   void * jresult ;
33865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33866   std::string *arg2 = 0 ;
33867   Dali::Actor result;
33868
33869   arg1 = (Dali::Actor *)jarg1;
33870   if (!jarg2) {
33871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33872     return 0;
33873   }
33874   std::string arg2_str(jarg2);
33875   arg2 = &arg2_str;
33876   {
33877     try {
33878       result = (arg1)->FindChildByName((std::string const &)*arg2);
33879     } catch (std::out_of_range& e) {
33880       {
33881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33882       };
33883     } catch (std::exception& e) {
33884       {
33885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33886       };
33887     } catch (Dali::DaliException e) {
33888       {
33889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33890       };
33891     } catch (...) {
33892       {
33893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33894       };
33895     }
33896   }
33897
33898   jresult = new Dali::Actor((const Dali::Actor &)result);
33899
33900   //argout typemap for const std::string&
33901
33902   return jresult;
33903 }
33904
33905
33906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
33907   void * jresult ;
33908   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33909   unsigned int arg2 ;
33910   Dali::Actor result;
33911
33912   arg1 = (Dali::Actor *)jarg1;
33913   arg2 = (unsigned int)jarg2;
33914   {
33915     try {
33916       result = (arg1)->FindChildById(arg2);
33917     } catch (std::out_of_range& e) {
33918       {
33919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33920       };
33921     } catch (std::exception& e) {
33922       {
33923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33924       };
33925     } catch (Dali::DaliException e) {
33926       {
33927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33928       };
33929     } catch (...) {
33930       {
33931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33932       };
33933     }
33934   }
33935
33936   jresult = new Dali::Actor((const Dali::Actor &)result);
33937   return jresult;
33938 }
33939
33940
33941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
33942   void * jresult ;
33943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33944   Dali::Actor result;
33945
33946   arg1 = (Dali::Actor *)jarg1;
33947   {
33948     try {
33949       result = ((Dali::Actor const *)arg1)->GetParent();
33950     } catch (std::out_of_range& e) {
33951       {
33952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33953       };
33954     } catch (std::exception& e) {
33955       {
33956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33957       };
33958     } catch (Dali::DaliException e) {
33959       {
33960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33961       };
33962     } catch (...) {
33963       {
33964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33965       };
33966     }
33967   }
33968
33969   jresult = new Dali::Actor((const Dali::Actor &)result);
33970   return jresult;
33971 }
33972
33973
33974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
33975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33976   Dali::Vector3 *arg2 = 0 ;
33977
33978   arg1 = (Dali::Actor *)jarg1;
33979   arg2 = (Dali::Vector3 *)jarg2;
33980   if (!arg2) {
33981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33982     return ;
33983   }
33984   {
33985     try {
33986       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
33987     } catch (std::out_of_range& e) {
33988       {
33989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33990       };
33991     } catch (std::exception& e) {
33992       {
33993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33994       };
33995     } catch (Dali::DaliException e) {
33996       {
33997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33998       };
33999     } catch (...) {
34000       {
34001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34002       };
34003     }
34004   }
34005
34006 }
34007
34008
34009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34010   void * jresult ;
34011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34012   Dali::Vector3 result;
34013
34014   arg1 = (Dali::Actor *)jarg1;
34015   {
34016     try {
34017       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34018     } catch (std::out_of_range& e) {
34019       {
34020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34021       };
34022     } catch (std::exception& e) {
34023       {
34024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34025       };
34026     } catch (Dali::DaliException e) {
34027       {
34028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34029       };
34030     } catch (...) {
34031       {
34032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34033       };
34034     }
34035   }
34036
34037   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34038   return jresult;
34039 }
34040
34041
34042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34043   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34044   Dali::Vector3 *arg2 = 0 ;
34045
34046   arg1 = (Dali::Actor *)jarg1;
34047   arg2 = (Dali::Vector3 *)jarg2;
34048   if (!arg2) {
34049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34050     return ;
34051   }
34052   {
34053     try {
34054       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34055     } catch (std::out_of_range& e) {
34056       {
34057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34058       };
34059     } catch (std::exception& e) {
34060       {
34061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34062       };
34063     } catch (Dali::DaliException e) {
34064       {
34065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34066       };
34067     } catch (...) {
34068       {
34069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34070       };
34071     }
34072   }
34073
34074 }
34075
34076
34077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34078   void * jresult ;
34079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34080   Dali::Vector3 result;
34081
34082   arg1 = (Dali::Actor *)jarg1;
34083   {
34084     try {
34085       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34086     } catch (std::out_of_range& e) {
34087       {
34088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34089       };
34090     } catch (std::exception& e) {
34091       {
34092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34093       };
34094     } catch (Dali::DaliException e) {
34095       {
34096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34097       };
34098     } catch (...) {
34099       {
34100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34101       };
34102     }
34103   }
34104
34105   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34106   return jresult;
34107 }
34108
34109
34110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34112   float arg2 ;
34113   float arg3 ;
34114
34115   arg1 = (Dali::Actor *)jarg1;
34116   arg2 = (float)jarg2;
34117   arg3 = (float)jarg3;
34118   {
34119     try {
34120       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34121     } catch (std::out_of_range& e) {
34122       {
34123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34124       };
34125     } catch (std::exception& e) {
34126       {
34127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34128       };
34129     } catch (Dali::DaliException e) {
34130       {
34131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34132       };
34133     } catch (...) {
34134       {
34135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34136       };
34137     }
34138   }
34139
34140 }
34141
34142
34143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34145   float arg2 ;
34146   float arg3 ;
34147   float arg4 ;
34148
34149   arg1 = (Dali::Actor *)jarg1;
34150   arg2 = (float)jarg2;
34151   arg3 = (float)jarg3;
34152   arg4 = (float)jarg4;
34153   {
34154     try {
34155       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34156     } catch (std::out_of_range& e) {
34157       {
34158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34159       };
34160     } catch (std::exception& e) {
34161       {
34162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34163       };
34164     } catch (Dali::DaliException e) {
34165       {
34166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34167       };
34168     } catch (...) {
34169       {
34170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34171       };
34172     }
34173   }
34174
34175 }
34176
34177
34178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34179   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34180   Dali::Vector2 *arg2 = 0 ;
34181
34182   arg1 = (Dali::Actor *)jarg1;
34183   arg2 = (Dali::Vector2 *)jarg2;
34184   if (!arg2) {
34185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34186     return ;
34187   }
34188   {
34189     try {
34190       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34191     } catch (std::out_of_range& e) {
34192       {
34193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34194       };
34195     } catch (std::exception& e) {
34196       {
34197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34198       };
34199     } catch (Dali::DaliException e) {
34200       {
34201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34202       };
34203     } catch (...) {
34204       {
34205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34206       };
34207     }
34208   }
34209
34210 }
34211
34212
34213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34215   Dali::Vector3 *arg2 = 0 ;
34216
34217   arg1 = (Dali::Actor *)jarg1;
34218   arg2 = (Dali::Vector3 *)jarg2;
34219   if (!arg2) {
34220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34221     return ;
34222   }
34223   {
34224     try {
34225       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34226     } catch (std::out_of_range& e) {
34227       {
34228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34229       };
34230     } catch (std::exception& e) {
34231       {
34232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34233       };
34234     } catch (Dali::DaliException e) {
34235       {
34236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34237       };
34238     } catch (...) {
34239       {
34240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34241       };
34242     }
34243   }
34244
34245 }
34246
34247
34248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34249   void * jresult ;
34250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34251   Dali::Vector3 result;
34252
34253   arg1 = (Dali::Actor *)jarg1;
34254   {
34255     try {
34256       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34257     } catch (std::out_of_range& e) {
34258       {
34259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34260       };
34261     } catch (std::exception& e) {
34262       {
34263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34264       };
34265     } catch (Dali::DaliException e) {
34266       {
34267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34268       };
34269     } catch (...) {
34270       {
34271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34272       };
34273     }
34274   }
34275
34276   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34277   return jresult;
34278 }
34279
34280
34281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34282   void * jresult ;
34283   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34284   Dali::Vector3 result;
34285
34286   arg1 = (Dali::Actor *)jarg1;
34287   {
34288     try {
34289       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34290     } catch (std::out_of_range& e) {
34291       {
34292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34293       };
34294     } catch (std::exception& e) {
34295       {
34296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34297       };
34298     } catch (Dali::DaliException e) {
34299       {
34300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34301       };
34302     } catch (...) {
34303       {
34304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34305       };
34306     }
34307   }
34308
34309   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34310   return jresult;
34311 }
34312
34313
34314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34315   void * jresult ;
34316   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34317   Dali::Vector3 result;
34318
34319   arg1 = (Dali::Actor *)jarg1;
34320   {
34321     try {
34322       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34323     } catch (std::out_of_range& e) {
34324       {
34325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34326       };
34327     } catch (std::exception& e) {
34328       {
34329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34330       };
34331     } catch (Dali::DaliException e) {
34332       {
34333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34334       };
34335     } catch (...) {
34336       {
34337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34338       };
34339     }
34340   }
34341
34342   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34343   return jresult;
34344 }
34345
34346
34347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34348   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34349   float arg2 ;
34350   float arg3 ;
34351
34352   arg1 = (Dali::Actor *)jarg1;
34353   arg2 = (float)jarg2;
34354   arg3 = (float)jarg3;
34355   {
34356     try {
34357       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34358     } catch (std::out_of_range& e) {
34359       {
34360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34361       };
34362     } catch (std::exception& e) {
34363       {
34364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34365       };
34366     } catch (Dali::DaliException e) {
34367       {
34368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34369       };
34370     } catch (...) {
34371       {
34372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34373       };
34374     }
34375   }
34376
34377 }
34378
34379
34380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34382   float arg2 ;
34383   float arg3 ;
34384   float arg4 ;
34385
34386   arg1 = (Dali::Actor *)jarg1;
34387   arg2 = (float)jarg2;
34388   arg3 = (float)jarg3;
34389   arg4 = (float)jarg4;
34390   {
34391     try {
34392       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34393     } catch (std::out_of_range& e) {
34394       {
34395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34396       };
34397     } catch (std::exception& e) {
34398       {
34399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34400       };
34401     } catch (Dali::DaliException e) {
34402       {
34403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34404       };
34405     } catch (...) {
34406       {
34407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34408       };
34409     }
34410   }
34411
34412 }
34413
34414
34415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34417   Dali::Vector3 *arg2 = 0 ;
34418
34419   arg1 = (Dali::Actor *)jarg1;
34420   arg2 = (Dali::Vector3 *)jarg2;
34421   if (!arg2) {
34422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34423     return ;
34424   }
34425   {
34426     try {
34427       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34428     } catch (std::out_of_range& e) {
34429       {
34430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34431       };
34432     } catch (std::exception& e) {
34433       {
34434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34435       };
34436     } catch (Dali::DaliException e) {
34437       {
34438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34439       };
34440     } catch (...) {
34441       {
34442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34443       };
34444     }
34445   }
34446
34447 }
34448
34449
34450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34452   float arg2 ;
34453
34454   arg1 = (Dali::Actor *)jarg1;
34455   arg2 = (float)jarg2;
34456   {
34457     try {
34458       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34459     } catch (std::out_of_range& e) {
34460       {
34461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34462       };
34463     } catch (std::exception& e) {
34464       {
34465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34466       };
34467     } catch (Dali::DaliException e) {
34468       {
34469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34470       };
34471     } catch (...) {
34472       {
34473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34474       };
34475     }
34476   }
34477
34478 }
34479
34480
34481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34483   float arg2 ;
34484
34485   arg1 = (Dali::Actor *)jarg1;
34486   arg2 = (float)jarg2;
34487   {
34488     try {
34489       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34490     } catch (std::out_of_range& e) {
34491       {
34492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34493       };
34494     } catch (std::exception& e) {
34495       {
34496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34497       };
34498     } catch (Dali::DaliException e) {
34499       {
34500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34501       };
34502     } catch (...) {
34503       {
34504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34505       };
34506     }
34507   }
34508
34509 }
34510
34511
34512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34513   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34514   float arg2 ;
34515
34516   arg1 = (Dali::Actor *)jarg1;
34517   arg2 = (float)jarg2;
34518   {
34519     try {
34520       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34521     } catch (std::out_of_range& e) {
34522       {
34523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34524       };
34525     } catch (std::exception& e) {
34526       {
34527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34528       };
34529     } catch (Dali::DaliException e) {
34530       {
34531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34532       };
34533     } catch (...) {
34534       {
34535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34536       };
34537     }
34538   }
34539
34540 }
34541
34542
34543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34545   Dali::Vector3 *arg2 = 0 ;
34546
34547   arg1 = (Dali::Actor *)jarg1;
34548   arg2 = (Dali::Vector3 *)jarg2;
34549   if (!arg2) {
34550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34551     return ;
34552   }
34553   {
34554     try {
34555       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34556     } catch (std::out_of_range& e) {
34557       {
34558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34559       };
34560     } catch (std::exception& e) {
34561       {
34562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34563       };
34564     } catch (Dali::DaliException e) {
34565       {
34566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34567       };
34568     } catch (...) {
34569       {
34570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34571       };
34572     }
34573   }
34574
34575 }
34576
34577
34578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34579   void * jresult ;
34580   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34581   Dali::Vector3 result;
34582
34583   arg1 = (Dali::Actor *)jarg1;
34584   {
34585     try {
34586       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34587     } catch (std::out_of_range& e) {
34588       {
34589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34590       };
34591     } catch (std::exception& e) {
34592       {
34593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34594       };
34595     } catch (Dali::DaliException e) {
34596       {
34597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34598       };
34599     } catch (...) {
34600       {
34601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34602       };
34603     }
34604   }
34605
34606   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34607   return jresult;
34608 }
34609
34610
34611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34612   void * jresult ;
34613   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34614   Dali::Vector3 result;
34615
34616   arg1 = (Dali::Actor *)jarg1;
34617   {
34618     try {
34619       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34620     } catch (std::out_of_range& e) {
34621       {
34622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34623       };
34624     } catch (std::exception& e) {
34625       {
34626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34627       };
34628     } catch (Dali::DaliException e) {
34629       {
34630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34631       };
34632     } catch (...) {
34633       {
34634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34635       };
34636     }
34637   }
34638
34639   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34640   return jresult;
34641 }
34642
34643
34644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34645   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34646   bool arg2 ;
34647
34648   arg1 = (Dali::Actor *)jarg1;
34649   arg2 = jarg2 ? true : false;
34650   {
34651     try {
34652       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34653     } catch (std::out_of_range& e) {
34654       {
34655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34656       };
34657     } catch (std::exception& e) {
34658       {
34659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34660       };
34661     } catch (Dali::DaliException e) {
34662       {
34663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34664       };
34665     } catch (...) {
34666       {
34667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34668       };
34669     }
34670   }
34671
34672 }
34673
34674
34675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34676   unsigned int jresult ;
34677   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34678   bool result;
34679
34680   arg1 = (Dali::Actor *)jarg1;
34681   {
34682     try {
34683       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34684     } catch (std::out_of_range& e) {
34685       {
34686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34687       };
34688     } catch (std::exception& e) {
34689       {
34690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34691       };
34692     } catch (Dali::DaliException e) {
34693       {
34694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34695       };
34696     } catch (...) {
34697       {
34698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34699       };
34700     }
34701   }
34702
34703   jresult = result;
34704   return jresult;
34705 }
34706
34707
34708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34709   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34710   Dali::Degree *arg2 = 0 ;
34711   Dali::Vector3 *arg3 = 0 ;
34712
34713   arg1 = (Dali::Actor *)jarg1;
34714   arg2 = (Dali::Degree *)jarg2;
34715   if (!arg2) {
34716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34717     return ;
34718   }
34719   arg3 = (Dali::Vector3 *)jarg3;
34720   if (!arg3) {
34721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34722     return ;
34723   }
34724   {
34725     try {
34726       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34727     } catch (std::out_of_range& e) {
34728       {
34729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34730       };
34731     } catch (std::exception& e) {
34732       {
34733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34734       };
34735     } catch (Dali::DaliException e) {
34736       {
34737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34738       };
34739     } catch (...) {
34740       {
34741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34742       };
34743     }
34744   }
34745
34746 }
34747
34748
34749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34751   Dali::Radian *arg2 = 0 ;
34752   Dali::Vector3 *arg3 = 0 ;
34753
34754   arg1 = (Dali::Actor *)jarg1;
34755   arg2 = (Dali::Radian *)jarg2;
34756   if (!arg2) {
34757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34758     return ;
34759   }
34760   arg3 = (Dali::Vector3 *)jarg3;
34761   if (!arg3) {
34762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34763     return ;
34764   }
34765   {
34766     try {
34767       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34768     } catch (std::out_of_range& e) {
34769       {
34770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34771       };
34772     } catch (std::exception& e) {
34773       {
34774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34775       };
34776     } catch (Dali::DaliException e) {
34777       {
34778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34779       };
34780     } catch (...) {
34781       {
34782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34783       };
34784     }
34785   }
34786
34787 }
34788
34789
34790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34791   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34792   Dali::Quaternion *arg2 = 0 ;
34793
34794   arg1 = (Dali::Actor *)jarg1;
34795   arg2 = (Dali::Quaternion *)jarg2;
34796   if (!arg2) {
34797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34798     return ;
34799   }
34800   {
34801     try {
34802       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34803     } catch (std::out_of_range& e) {
34804       {
34805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34806       };
34807     } catch (std::exception& e) {
34808       {
34809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34810       };
34811     } catch (Dali::DaliException e) {
34812       {
34813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34814       };
34815     } catch (...) {
34816       {
34817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34818       };
34819     }
34820   }
34821
34822 }
34823
34824
34825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34826   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34827   Dali::Degree *arg2 = 0 ;
34828   Dali::Vector3 *arg3 = 0 ;
34829
34830   arg1 = (Dali::Actor *)jarg1;
34831   arg2 = (Dali::Degree *)jarg2;
34832   if (!arg2) {
34833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34834     return ;
34835   }
34836   arg3 = (Dali::Vector3 *)jarg3;
34837   if (!arg3) {
34838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34839     return ;
34840   }
34841   {
34842     try {
34843       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34844     } catch (std::out_of_range& e) {
34845       {
34846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34847       };
34848     } catch (std::exception& e) {
34849       {
34850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34851       };
34852     } catch (Dali::DaliException e) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34855       };
34856     } catch (...) {
34857       {
34858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34859       };
34860     }
34861   }
34862
34863 }
34864
34865
34866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34867   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34868   Dali::Radian *arg2 = 0 ;
34869   Dali::Vector3 *arg3 = 0 ;
34870
34871   arg1 = (Dali::Actor *)jarg1;
34872   arg2 = (Dali::Radian *)jarg2;
34873   if (!arg2) {
34874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34875     return ;
34876   }
34877   arg3 = (Dali::Vector3 *)jarg3;
34878   if (!arg3) {
34879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34880     return ;
34881   }
34882   {
34883     try {
34884       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34885     } catch (std::out_of_range& e) {
34886       {
34887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34888       };
34889     } catch (std::exception& e) {
34890       {
34891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34892       };
34893     } catch (Dali::DaliException e) {
34894       {
34895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34896       };
34897     } catch (...) {
34898       {
34899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34900       };
34901     }
34902   }
34903
34904 }
34905
34906
34907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
34908   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34909   Dali::Quaternion *arg2 = 0 ;
34910
34911   arg1 = (Dali::Actor *)jarg1;
34912   arg2 = (Dali::Quaternion *)jarg2;
34913   if (!arg2) {
34914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34915     return ;
34916   }
34917   {
34918     try {
34919       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
34920     } catch (std::out_of_range& e) {
34921       {
34922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34923       };
34924     } catch (std::exception& e) {
34925       {
34926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34927       };
34928     } catch (Dali::DaliException e) {
34929       {
34930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34931       };
34932     } catch (...) {
34933       {
34934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34935       };
34936     }
34937   }
34938
34939 }
34940
34941
34942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
34943   void * jresult ;
34944   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34945   Dali::Quaternion result;
34946
34947   arg1 = (Dali::Actor *)jarg1;
34948   {
34949     try {
34950       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
34951     } catch (std::out_of_range& e) {
34952       {
34953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34954       };
34955     } catch (std::exception& e) {
34956       {
34957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34958       };
34959     } catch (Dali::DaliException e) {
34960       {
34961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34962       };
34963     } catch (...) {
34964       {
34965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34966       };
34967     }
34968   }
34969
34970   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
34971   return jresult;
34972 }
34973
34974
34975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
34976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34977   bool arg2 ;
34978
34979   arg1 = (Dali::Actor *)jarg1;
34980   arg2 = jarg2 ? true : false;
34981   {
34982     try {
34983       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
34984     } catch (std::out_of_range& e) {
34985       {
34986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34987       };
34988     } catch (std::exception& e) {
34989       {
34990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34991       };
34992     } catch (Dali::DaliException e) {
34993       {
34994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34995       };
34996     } catch (...) {
34997       {
34998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34999       };
35000     }
35001   }
35002
35003 }
35004
35005
35006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35007   unsigned int jresult ;
35008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35009   bool result;
35010
35011   arg1 = (Dali::Actor *)jarg1;
35012   {
35013     try {
35014       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35015     } catch (std::out_of_range& e) {
35016       {
35017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35018       };
35019     } catch (std::exception& e) {
35020       {
35021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35022       };
35023     } catch (Dali::DaliException e) {
35024       {
35025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35026       };
35027     } catch (...) {
35028       {
35029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35030       };
35031     }
35032   }
35033
35034   jresult = result;
35035   return jresult;
35036 }
35037
35038
35039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35040   void * jresult ;
35041   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35042   Dali::Quaternion result;
35043
35044   arg1 = (Dali::Actor *)jarg1;
35045   {
35046     try {
35047       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35048     } catch (std::out_of_range& e) {
35049       {
35050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35051       };
35052     } catch (std::exception& e) {
35053       {
35054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35055       };
35056     } catch (Dali::DaliException e) {
35057       {
35058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35059       };
35060     } catch (...) {
35061       {
35062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35063       };
35064     }
35065   }
35066
35067   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35068   return jresult;
35069 }
35070
35071
35072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35073   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35074   float arg2 ;
35075
35076   arg1 = (Dali::Actor *)jarg1;
35077   arg2 = (float)jarg2;
35078   {
35079     try {
35080       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35081     } catch (std::out_of_range& e) {
35082       {
35083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35084       };
35085     } catch (std::exception& e) {
35086       {
35087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35088       };
35089     } catch (Dali::DaliException e) {
35090       {
35091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35092       };
35093     } catch (...) {
35094       {
35095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35096       };
35097     }
35098   }
35099
35100 }
35101
35102
35103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35104   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35105   float arg2 ;
35106   float arg3 ;
35107   float arg4 ;
35108
35109   arg1 = (Dali::Actor *)jarg1;
35110   arg2 = (float)jarg2;
35111   arg3 = (float)jarg3;
35112   arg4 = (float)jarg4;
35113   {
35114     try {
35115       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35116     } catch (std::out_of_range& e) {
35117       {
35118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35119       };
35120     } catch (std::exception& e) {
35121       {
35122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35123       };
35124     } catch (Dali::DaliException e) {
35125       {
35126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35127       };
35128     } catch (...) {
35129       {
35130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35131       };
35132     }
35133   }
35134
35135 }
35136
35137
35138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35140   Dali::Vector3 *arg2 = 0 ;
35141
35142   arg1 = (Dali::Actor *)jarg1;
35143   arg2 = (Dali::Vector3 *)jarg2;
35144   if (!arg2) {
35145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35146     return ;
35147   }
35148   {
35149     try {
35150       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35151     } catch (std::out_of_range& e) {
35152       {
35153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35154       };
35155     } catch (std::exception& e) {
35156       {
35157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35158       };
35159     } catch (Dali::DaliException e) {
35160       {
35161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35162       };
35163     } catch (...) {
35164       {
35165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35166       };
35167     }
35168   }
35169
35170 }
35171
35172
35173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35174   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35175   Dali::Vector3 *arg2 = 0 ;
35176
35177   arg1 = (Dali::Actor *)jarg1;
35178   arg2 = (Dali::Vector3 *)jarg2;
35179   if (!arg2) {
35180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35181     return ;
35182   }
35183   {
35184     try {
35185       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35186     } catch (std::out_of_range& e) {
35187       {
35188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35189       };
35190     } catch (std::exception& e) {
35191       {
35192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35193       };
35194     } catch (Dali::DaliException e) {
35195       {
35196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35197       };
35198     } catch (...) {
35199       {
35200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35201       };
35202     }
35203   }
35204
35205 }
35206
35207
35208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35209   void * jresult ;
35210   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35211   Dali::Vector3 result;
35212
35213   arg1 = (Dali::Actor *)jarg1;
35214   {
35215     try {
35216       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35217     } catch (std::out_of_range& e) {
35218       {
35219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35220       };
35221     } catch (std::exception& e) {
35222       {
35223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35224       };
35225     } catch (Dali::DaliException e) {
35226       {
35227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35228       };
35229     } catch (...) {
35230       {
35231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35232       };
35233     }
35234   }
35235
35236   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35237   return jresult;
35238 }
35239
35240
35241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35242   void * jresult ;
35243   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35244   Dali::Vector3 result;
35245
35246   arg1 = (Dali::Actor *)jarg1;
35247   {
35248     try {
35249       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35250     } catch (std::out_of_range& e) {
35251       {
35252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35253       };
35254     } catch (std::exception& e) {
35255       {
35256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35257       };
35258     } catch (Dali::DaliException e) {
35259       {
35260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35261       };
35262     } catch (...) {
35263       {
35264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35265       };
35266     }
35267   }
35268
35269   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35270   return jresult;
35271 }
35272
35273
35274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35275   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35276   bool arg2 ;
35277
35278   arg1 = (Dali::Actor *)jarg1;
35279   arg2 = jarg2 ? true : false;
35280   {
35281     try {
35282       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35283     } catch (std::out_of_range& e) {
35284       {
35285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35286       };
35287     } catch (std::exception& e) {
35288       {
35289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35290       };
35291     } catch (Dali::DaliException e) {
35292       {
35293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35294       };
35295     } catch (...) {
35296       {
35297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35298       };
35299     }
35300   }
35301
35302 }
35303
35304
35305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35306   unsigned int jresult ;
35307   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35308   bool result;
35309
35310   arg1 = (Dali::Actor *)jarg1;
35311   {
35312     try {
35313       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35314     } catch (std::out_of_range& e) {
35315       {
35316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35317       };
35318     } catch (std::exception& e) {
35319       {
35320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35321       };
35322     } catch (Dali::DaliException e) {
35323       {
35324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35325       };
35326     } catch (...) {
35327       {
35328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35329       };
35330     }
35331   }
35332
35333   jresult = result;
35334   return jresult;
35335 }
35336
35337
35338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35339   void * jresult ;
35340   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35341   Dali::Matrix result;
35342
35343   arg1 = (Dali::Actor *)jarg1;
35344   {
35345     try {
35346       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35347     } catch (std::out_of_range& e) {
35348       {
35349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35350       };
35351     } catch (std::exception& e) {
35352       {
35353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35354       };
35355     } catch (Dali::DaliException e) {
35356       {
35357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35358       };
35359     } catch (...) {
35360       {
35361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35362       };
35363     }
35364   }
35365
35366   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35367   return jresult;
35368 }
35369
35370
35371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35372   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35373   bool arg2 ;
35374
35375   arg1 = (Dali::Actor *)jarg1;
35376   arg2 = jarg2 ? true : false;
35377   {
35378     try {
35379       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35380     } catch (std::out_of_range& e) {
35381       {
35382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35383       };
35384     } catch (std::exception& e) {
35385       {
35386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35387       };
35388     } catch (Dali::DaliException e) {
35389       {
35390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35391       };
35392     } catch (...) {
35393       {
35394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35395       };
35396     }
35397   }
35398
35399 }
35400
35401
35402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35403   unsigned int jresult ;
35404   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35405   bool result;
35406
35407   arg1 = (Dali::Actor *)jarg1;
35408   {
35409     try {
35410       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35411     } catch (std::out_of_range& e) {
35412       {
35413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35414       };
35415     } catch (std::exception& e) {
35416       {
35417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35418       };
35419     } catch (Dali::DaliException e) {
35420       {
35421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35422       };
35423     } catch (...) {
35424       {
35425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35426       };
35427     }
35428   }
35429
35430   jresult = result;
35431   return jresult;
35432 }
35433
35434
35435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35436   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35437   float arg2 ;
35438
35439   arg1 = (Dali::Actor *)jarg1;
35440   arg2 = (float)jarg2;
35441   {
35442     try {
35443       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35444     } catch (std::out_of_range& e) {
35445       {
35446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35447       };
35448     } catch (std::exception& e) {
35449       {
35450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35451       };
35452     } catch (Dali::DaliException e) {
35453       {
35454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35455       };
35456     } catch (...) {
35457       {
35458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35459       };
35460     }
35461   }
35462
35463 }
35464
35465
35466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35467   float jresult ;
35468   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35469   float result;
35470
35471   arg1 = (Dali::Actor *)jarg1;
35472   {
35473     try {
35474       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35475     } catch (std::out_of_range& e) {
35476       {
35477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35478       };
35479     } catch (std::exception& e) {
35480       {
35481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35482       };
35483     } catch (Dali::DaliException e) {
35484       {
35485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35486       };
35487     } catch (...) {
35488       {
35489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35490       };
35491     }
35492   }
35493
35494   jresult = result;
35495   return jresult;
35496 }
35497
35498
35499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35500   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35501   Dali::Vector4 *arg2 = 0 ;
35502
35503   arg1 = (Dali::Actor *)jarg1;
35504   arg2 = (Dali::Vector4 *)jarg2;
35505   if (!arg2) {
35506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35507     return ;
35508   }
35509   {
35510     try {
35511       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35512     } catch (std::out_of_range& e) {
35513       {
35514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35515       };
35516     } catch (std::exception& e) {
35517       {
35518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35519       };
35520     } catch (Dali::DaliException e) {
35521       {
35522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35523       };
35524     } catch (...) {
35525       {
35526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35527       };
35528     }
35529   }
35530
35531 }
35532
35533
35534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35535   void * jresult ;
35536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35537   Dali::Vector4 result;
35538
35539   arg1 = (Dali::Actor *)jarg1;
35540   {
35541     try {
35542       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35543     } catch (std::out_of_range& e) {
35544       {
35545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35546       };
35547     } catch (std::exception& e) {
35548       {
35549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35550       };
35551     } catch (Dali::DaliException e) {
35552       {
35553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35554       };
35555     } catch (...) {
35556       {
35557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35558       };
35559     }
35560   }
35561
35562   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35563   return jresult;
35564 }
35565
35566
35567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35568   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35569   Dali::ColorMode arg2 ;
35570
35571   arg1 = (Dali::Actor *)jarg1;
35572   arg2 = (Dali::ColorMode)jarg2;
35573   {
35574     try {
35575       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35576     } catch (std::out_of_range& e) {
35577       {
35578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35579       };
35580     } catch (std::exception& e) {
35581       {
35582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35583       };
35584     } catch (Dali::DaliException e) {
35585       {
35586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35587       };
35588     } catch (...) {
35589       {
35590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35591       };
35592     }
35593   }
35594
35595 }
35596
35597
35598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35599   int jresult ;
35600   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35601   Dali::ColorMode result;
35602
35603   arg1 = (Dali::Actor *)jarg1;
35604   {
35605     try {
35606       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35607     } catch (std::out_of_range& e) {
35608       {
35609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35610       };
35611     } catch (std::exception& e) {
35612       {
35613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35614       };
35615     } catch (Dali::DaliException e) {
35616       {
35617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35618       };
35619     } catch (...) {
35620       {
35621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35622       };
35623     }
35624   }
35625
35626   jresult = (int)result;
35627   return jresult;
35628 }
35629
35630
35631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35632   void * jresult ;
35633   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35634   Dali::Vector4 result;
35635
35636   arg1 = (Dali::Actor *)jarg1;
35637   {
35638     try {
35639       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35640     } catch (std::out_of_range& e) {
35641       {
35642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35643       };
35644     } catch (std::exception& e) {
35645       {
35646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35647       };
35648     } catch (Dali::DaliException e) {
35649       {
35650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35651       };
35652     } catch (...) {
35653       {
35654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35655       };
35656     }
35657   }
35658
35659   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35660   return jresult;
35661 }
35662
35663
35664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35665   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35666   Dali::DrawMode::Type arg2 ;
35667
35668   arg1 = (Dali::Actor *)jarg1;
35669   arg2 = (Dali::DrawMode::Type)jarg2;
35670   {
35671     try {
35672       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35673     } catch (std::out_of_range& e) {
35674       {
35675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35676       };
35677     } catch (std::exception& e) {
35678       {
35679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35680       };
35681     } catch (Dali::DaliException e) {
35682       {
35683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35684       };
35685     } catch (...) {
35686       {
35687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35688       };
35689     }
35690   }
35691
35692 }
35693
35694
35695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35696   int jresult ;
35697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35698   Dali::DrawMode::Type result;
35699
35700   arg1 = (Dali::Actor *)jarg1;
35701   {
35702     try {
35703       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35704     } catch (std::out_of_range& e) {
35705       {
35706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35707       };
35708     } catch (std::exception& e) {
35709       {
35710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35711       };
35712     } catch (Dali::DaliException e) {
35713       {
35714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35715       };
35716     } catch (...) {
35717       {
35718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35719       };
35720     }
35721   }
35722
35723   jresult = (int)result;
35724   return jresult;
35725 }
35726
35727
35728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35730   bool arg2 ;
35731
35732   arg1 = (Dali::Actor *)jarg1;
35733   arg2 = jarg2 ? true : false;
35734   {
35735     try {
35736       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35737     } catch (std::out_of_range& e) {
35738       {
35739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35740       };
35741     } catch (std::exception& e) {
35742       {
35743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35744       };
35745     } catch (Dali::DaliException e) {
35746       {
35747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35748       };
35749     } catch (...) {
35750       {
35751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35752       };
35753     }
35754   }
35755
35756 }
35757
35758
35759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35760   unsigned int jresult ;
35761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35762   bool result;
35763
35764   arg1 = (Dali::Actor *)jarg1;
35765   {
35766     try {
35767       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35768     } catch (std::out_of_range& e) {
35769       {
35770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35771       };
35772     } catch (std::exception& e) {
35773       {
35774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35775       };
35776     } catch (Dali::DaliException e) {
35777       {
35778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35779       };
35780     } catch (...) {
35781       {
35782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35783       };
35784     }
35785   }
35786
35787   jresult = result;
35788   return jresult;
35789 }
35790
35791
35792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35793   unsigned int jresult ;
35794   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35795   float *arg2 = 0 ;
35796   float *arg3 = 0 ;
35797   float arg4 ;
35798   float arg5 ;
35799   bool result;
35800
35801   arg1 = (Dali::Actor *)jarg1;
35802   arg2 = (float *)jarg2;
35803   arg3 = (float *)jarg3;
35804   arg4 = (float)jarg4;
35805   arg5 = (float)jarg5;
35806   {
35807     try {
35808       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35809     } catch (std::out_of_range& e) {
35810       {
35811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35812       };
35813     } catch (std::exception& e) {
35814       {
35815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35816       };
35817     } catch (Dali::DaliException e) {
35818       {
35819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35820       };
35821     } catch (...) {
35822       {
35823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35824       };
35825     }
35826   }
35827
35828   jresult = result;
35829   return jresult;
35830 }
35831
35832
35833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35835   bool arg2 ;
35836
35837   arg1 = (Dali::Actor *)jarg1;
35838   arg2 = jarg2 ? true : false;
35839   {
35840     try {
35841       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
35842     } catch (std::out_of_range& e) {
35843       {
35844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35845       };
35846     } catch (std::exception& e) {
35847       {
35848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35849       };
35850     } catch (Dali::DaliException e) {
35851       {
35852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35853       };
35854     } catch (...) {
35855       {
35856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35857       };
35858     }
35859   }
35860
35861 }
35862
35863
35864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
35865   unsigned int jresult ;
35866   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35867   bool result;
35868
35869   arg1 = (Dali::Actor *)jarg1;
35870   {
35871     try {
35872       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
35873     } catch (std::out_of_range& e) {
35874       {
35875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35876       };
35877     } catch (std::exception& e) {
35878       {
35879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35880       };
35881     } catch (Dali::DaliException e) {
35882       {
35883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35884       };
35885     } catch (...) {
35886       {
35887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35888       };
35889     }
35890   }
35891
35892   jresult = result;
35893   return jresult;
35894 }
35895
35896
35897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
35898   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35899   bool arg2 ;
35900
35901   arg1 = (Dali::Actor *)jarg1;
35902   arg2 = jarg2 ? true : false;
35903   {
35904     try {
35905       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
35906     } catch (std::out_of_range& e) {
35907       {
35908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35909       };
35910     } catch (std::exception& e) {
35911       {
35912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35913       };
35914     } catch (Dali::DaliException e) {
35915       {
35916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35917       };
35918     } catch (...) {
35919       {
35920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35921       };
35922     }
35923   }
35924
35925 }
35926
35927
35928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
35929   unsigned int jresult ;
35930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35931   bool result;
35932
35933   arg1 = (Dali::Actor *)jarg1;
35934   {
35935     try {
35936       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
35937     } catch (std::out_of_range& e) {
35938       {
35939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35940       };
35941     } catch (std::exception& e) {
35942       {
35943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35944       };
35945     } catch (Dali::DaliException e) {
35946       {
35947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35948       };
35949     } catch (...) {
35950       {
35951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35952       };
35953     }
35954   }
35955
35956   jresult = result;
35957   return jresult;
35958 }
35959
35960
35961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
35962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35963   Dali::ResizePolicy::Type arg2 ;
35964   Dali::Dimension::Type arg3 ;
35965
35966   arg1 = (Dali::Actor *)jarg1;
35967   arg2 = (Dali::ResizePolicy::Type)jarg2;
35968   arg3 = (Dali::Dimension::Type)jarg3;
35969   {
35970     try {
35971       (arg1)->SetResizePolicy(arg2,arg3);
35972     } catch (std::out_of_range& e) {
35973       {
35974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35975       };
35976     } catch (std::exception& e) {
35977       {
35978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35979       };
35980     } catch (Dali::DaliException e) {
35981       {
35982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35983       };
35984     } catch (...) {
35985       {
35986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35987       };
35988     }
35989   }
35990
35991 }
35992
35993
35994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
35995   int jresult ;
35996   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35997   Dali::Dimension::Type arg2 ;
35998   Dali::ResizePolicy::Type result;
35999
36000   arg1 = (Dali::Actor *)jarg1;
36001   arg2 = (Dali::Dimension::Type)jarg2;
36002   {
36003     try {
36004       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36005     } catch (std::out_of_range& e) {
36006       {
36007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36008       };
36009     } catch (std::exception& e) {
36010       {
36011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36012       };
36013     } catch (Dali::DaliException e) {
36014       {
36015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36016       };
36017     } catch (...) {
36018       {
36019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36020       };
36021     }
36022   }
36023
36024   jresult = (int)result;
36025   return jresult;
36026 }
36027
36028
36029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36030   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36031   Dali::SizeScalePolicy::Type arg2 ;
36032
36033   arg1 = (Dali::Actor *)jarg1;
36034   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36035   {
36036     try {
36037       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36038     } catch (std::out_of_range& e) {
36039       {
36040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36041       };
36042     } catch (std::exception& e) {
36043       {
36044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36045       };
36046     } catch (Dali::DaliException e) {
36047       {
36048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36049       };
36050     } catch (...) {
36051       {
36052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36053       };
36054     }
36055   }
36056
36057 }
36058
36059
36060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36061   int jresult ;
36062   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36063   Dali::SizeScalePolicy::Type result;
36064
36065   arg1 = (Dali::Actor *)jarg1;
36066   {
36067     try {
36068       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36069     } catch (std::out_of_range& e) {
36070       {
36071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36072       };
36073     } catch (std::exception& e) {
36074       {
36075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36076       };
36077     } catch (Dali::DaliException e) {
36078       {
36079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36080       };
36081     } catch (...) {
36082       {
36083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36084       };
36085     }
36086   }
36087
36088   jresult = (int)result;
36089   return jresult;
36090 }
36091
36092
36093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36094   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36095   Dali::Vector3 *arg2 = 0 ;
36096
36097   arg1 = (Dali::Actor *)jarg1;
36098   arg2 = (Dali::Vector3 *)jarg2;
36099   if (!arg2) {
36100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36101     return ;
36102   }
36103   {
36104     try {
36105       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36106     } catch (std::out_of_range& e) {
36107       {
36108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36109       };
36110     } catch (std::exception& e) {
36111       {
36112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36113       };
36114     } catch (Dali::DaliException e) {
36115       {
36116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36117       };
36118     } catch (...) {
36119       {
36120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36121       };
36122     }
36123   }
36124
36125 }
36126
36127
36128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36129   void * jresult ;
36130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36131   Dali::Vector3 result;
36132
36133   arg1 = (Dali::Actor *)jarg1;
36134   {
36135     try {
36136       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36137     } catch (std::out_of_range& e) {
36138       {
36139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36140       };
36141     } catch (std::exception& e) {
36142       {
36143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36144       };
36145     } catch (Dali::DaliException e) {
36146       {
36147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36148       };
36149     } catch (...) {
36150       {
36151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36152       };
36153     }
36154   }
36155
36156   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36157   return jresult;
36158 }
36159
36160
36161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36162   float jresult ;
36163   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36164   float arg2 ;
36165   float result;
36166
36167   arg1 = (Dali::Actor *)jarg1;
36168   arg2 = (float)jarg2;
36169   {
36170     try {
36171       result = (float)(arg1)->GetHeightForWidth(arg2);
36172     } catch (std::out_of_range& e) {
36173       {
36174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36175       };
36176     } catch (std::exception& e) {
36177       {
36178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36179       };
36180     } catch (Dali::DaliException e) {
36181       {
36182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36183       };
36184     } catch (...) {
36185       {
36186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36187       };
36188     }
36189   }
36190
36191   jresult = result;
36192   return jresult;
36193 }
36194
36195
36196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36197   float jresult ;
36198   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36199   float arg2 ;
36200   float result;
36201
36202   arg1 = (Dali::Actor *)jarg1;
36203   arg2 = (float)jarg2;
36204   {
36205     try {
36206       result = (float)(arg1)->GetWidthForHeight(arg2);
36207     } catch (std::out_of_range& e) {
36208       {
36209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36210       };
36211     } catch (std::exception& e) {
36212       {
36213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36214       };
36215     } catch (Dali::DaliException e) {
36216       {
36217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36218       };
36219     } catch (...) {
36220       {
36221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36222       };
36223     }
36224   }
36225
36226   jresult = result;
36227   return jresult;
36228 }
36229
36230
36231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36232   float jresult ;
36233   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36234   Dali::Dimension::Type arg2 ;
36235   float result;
36236
36237   arg1 = (Dali::Actor *)jarg1;
36238   arg2 = (Dali::Dimension::Type)jarg2;
36239   {
36240     try {
36241       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36242     } catch (std::out_of_range& e) {
36243       {
36244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36245       };
36246     } catch (std::exception& e) {
36247       {
36248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36249       };
36250     } catch (Dali::DaliException e) {
36251       {
36252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36253       };
36254     } catch (...) {
36255       {
36256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36257       };
36258     }
36259   }
36260
36261   jresult = result;
36262   return jresult;
36263 }
36264
36265
36266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36267   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36268   Dali::Padding *arg2 = 0 ;
36269
36270   arg1 = (Dali::Actor *)jarg1;
36271   arg2 = (Dali::Padding *)jarg2;
36272   if (!arg2) {
36273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36274     return ;
36275   }
36276   {
36277     try {
36278       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36279     } catch (std::out_of_range& e) {
36280       {
36281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36282       };
36283     } catch (std::exception& e) {
36284       {
36285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36286       };
36287     } catch (Dali::DaliException e) {
36288       {
36289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36290       };
36291     } catch (...) {
36292       {
36293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36294       };
36295     }
36296   }
36297
36298 }
36299
36300
36301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36302   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36303   Dali::Padding *arg2 = 0 ;
36304
36305   arg1 = (Dali::Actor *)jarg1;
36306   arg2 = (Dali::Padding *)jarg2;
36307   if (!arg2) {
36308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36309     return ;
36310   }
36311   {
36312     try {
36313       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36314     } catch (std::out_of_range& e) {
36315       {
36316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36317       };
36318     } catch (std::exception& e) {
36319       {
36320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36321       };
36322     } catch (Dali::DaliException e) {
36323       {
36324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36325       };
36326     } catch (...) {
36327       {
36328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36329       };
36330     }
36331   }
36332
36333 }
36334
36335
36336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36337   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36338   Dali::Vector2 *arg2 = 0 ;
36339
36340   arg1 = (Dali::Actor *)jarg1;
36341   arg2 = (Dali::Vector2 *)jarg2;
36342   if (!arg2) {
36343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36344     return ;
36345   }
36346   {
36347     try {
36348       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36349     } catch (std::out_of_range& e) {
36350       {
36351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36352       };
36353     } catch (std::exception& e) {
36354       {
36355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36356       };
36357     } catch (Dali::DaliException e) {
36358       {
36359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36360       };
36361     } catch (...) {
36362       {
36363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36364       };
36365     }
36366   }
36367
36368 }
36369
36370
36371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36372   void * jresult ;
36373   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36374   Dali::Vector2 result;
36375
36376   arg1 = (Dali::Actor *)jarg1;
36377   {
36378     try {
36379       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36380     } catch (std::out_of_range& e) {
36381       {
36382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36383       };
36384     } catch (std::exception& e) {
36385       {
36386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36387       };
36388     } catch (Dali::DaliException e) {
36389       {
36390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36391       };
36392     } catch (...) {
36393       {
36394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36395       };
36396     }
36397   }
36398
36399   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36400   return jresult;
36401 }
36402
36403
36404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36405   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36406   Dali::Vector2 *arg2 = 0 ;
36407
36408   arg1 = (Dali::Actor *)jarg1;
36409   arg2 = (Dali::Vector2 *)jarg2;
36410   if (!arg2) {
36411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36412     return ;
36413   }
36414   {
36415     try {
36416       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36417     } catch (std::out_of_range& e) {
36418       {
36419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36420       };
36421     } catch (std::exception& e) {
36422       {
36423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36424       };
36425     } catch (Dali::DaliException e) {
36426       {
36427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36428       };
36429     } catch (...) {
36430       {
36431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36432       };
36433     }
36434   }
36435
36436 }
36437
36438
36439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36440   void * jresult ;
36441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36442   Dali::Vector2 result;
36443
36444   arg1 = (Dali::Actor *)jarg1;
36445   {
36446     try {
36447       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36448     } catch (std::out_of_range& e) {
36449       {
36450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36451       };
36452     } catch (std::exception& e) {
36453       {
36454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36455       };
36456     } catch (Dali::DaliException e) {
36457       {
36458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36459       };
36460     } catch (...) {
36461       {
36462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36463       };
36464     }
36465   }
36466
36467   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36468   return jresult;
36469 }
36470
36471
36472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36473   int jresult ;
36474   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36475   int result;
36476
36477   arg1 = (Dali::Actor *)jarg1;
36478   {
36479     try {
36480       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36481       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36482     } catch (std::out_of_range& e) {
36483       {
36484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36485       };
36486     } catch (std::exception& e) {
36487       {
36488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36489       };
36490     } catch (Dali::DaliException e) {
36491       {
36492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36493       };
36494     } catch (...) {
36495       {
36496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36497       };
36498     }
36499   }
36500
36501   jresult = result;
36502   return jresult;
36503 }
36504
36505
36506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36507   unsigned int jresult ;
36508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36509   Dali::Renderer *arg2 = 0 ;
36510   unsigned int result;
36511
36512   arg1 = (Dali::Actor *)jarg1;
36513   arg2 = (Dali::Renderer *)jarg2;
36514   if (!arg2) {
36515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36516     return 0;
36517   }
36518   {
36519     try {
36520       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36521     } catch (std::out_of_range& e) {
36522       {
36523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36524       };
36525     } catch (std::exception& e) {
36526       {
36527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36528       };
36529     } catch (Dali::DaliException e) {
36530       {
36531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36532       };
36533     } catch (...) {
36534       {
36535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36536       };
36537     }
36538   }
36539
36540   jresult = result;
36541   return jresult;
36542 }
36543
36544
36545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36546   unsigned int jresult ;
36547   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36548   unsigned int result;
36549
36550   arg1 = (Dali::Actor *)jarg1;
36551   {
36552     try {
36553       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36554     } catch (std::out_of_range& e) {
36555       {
36556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36557       };
36558     } catch (std::exception& e) {
36559       {
36560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36561       };
36562     } catch (Dali::DaliException e) {
36563       {
36564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36565       };
36566     } catch (...) {
36567       {
36568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36569       };
36570     }
36571   }
36572
36573   jresult = result;
36574   return jresult;
36575 }
36576
36577
36578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36579   void * jresult ;
36580   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36581   unsigned int arg2 ;
36582   Dali::Renderer result;
36583
36584   arg1 = (Dali::Actor *)jarg1;
36585   arg2 = (unsigned int)jarg2;
36586   {
36587     try {
36588       result = (arg1)->GetRendererAt(arg2);
36589     } catch (std::out_of_range& e) {
36590       {
36591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36592       };
36593     } catch (std::exception& e) {
36594       {
36595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36596       };
36597     } catch (Dali::DaliException e) {
36598       {
36599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36600       };
36601     } catch (...) {
36602       {
36603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36604       };
36605     }
36606   }
36607
36608   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36609   return jresult;
36610 }
36611
36612
36613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36615   Dali::Renderer *arg2 = 0 ;
36616
36617   arg1 = (Dali::Actor *)jarg1;
36618   arg2 = (Dali::Renderer *)jarg2;
36619   if (!arg2) {
36620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36621     return ;
36622   }
36623   {
36624     try {
36625       (arg1)->RemoveRenderer(*arg2);
36626     } catch (std::out_of_range& e) {
36627       {
36628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36629       };
36630     } catch (std::exception& e) {
36631       {
36632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36633       };
36634     } catch (Dali::DaliException e) {
36635       {
36636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36637       };
36638     } catch (...) {
36639       {
36640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36641       };
36642     }
36643   }
36644
36645 }
36646
36647
36648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36649   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36650   unsigned int arg2 ;
36651
36652   arg1 = (Dali::Actor *)jarg1;
36653   arg2 = (unsigned int)jarg2;
36654   {
36655     try {
36656       (arg1)->RemoveRenderer(arg2);
36657     } catch (std::out_of_range& e) {
36658       {
36659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36660       };
36661     } catch (std::exception& e) {
36662       {
36663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36664       };
36665     } catch (Dali::DaliException e) {
36666       {
36667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36668       };
36669     } catch (...) {
36670       {
36671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36672       };
36673     }
36674   }
36675
36676 }
36677
36678
36679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36680   void * jresult ;
36681   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36682   Dali::Actor::TouchSignalType *result = 0 ;
36683
36684   arg1 = (Dali::Actor *)jarg1;
36685   {
36686     try {
36687       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36688     } catch (std::out_of_range& e) {
36689       {
36690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36691       };
36692     } catch (std::exception& e) {
36693       {
36694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36695       };
36696     } catch (Dali::DaliException e) {
36697       {
36698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36699       };
36700     } catch (...) {
36701       {
36702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36703       };
36704     }
36705   }
36706
36707   jresult = (void *)result;
36708   return jresult;
36709 }
36710
36711
36712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36713   void * jresult ;
36714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36715   Dali::Actor::TouchDataSignalType *result = 0 ;
36716
36717   arg1 = (Dali::Actor *)jarg1;
36718   {
36719     try {
36720       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36721     } catch (std::out_of_range& e) {
36722       {
36723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36724       };
36725     } catch (std::exception& e) {
36726       {
36727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36728       };
36729     } catch (Dali::DaliException e) {
36730       {
36731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36732       };
36733     } catch (...) {
36734       {
36735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36736       };
36737     }
36738   }
36739
36740   jresult = (void *)result;
36741   return jresult;
36742 }
36743
36744
36745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36746   void * jresult ;
36747   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36748   Dali::Actor::HoverSignalType *result = 0 ;
36749
36750   arg1 = (Dali::Actor *)jarg1;
36751   {
36752     try {
36753       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36754     } catch (std::out_of_range& e) {
36755       {
36756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36757       };
36758     } catch (std::exception& e) {
36759       {
36760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36761       };
36762     } catch (Dali::DaliException e) {
36763       {
36764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36765       };
36766     } catch (...) {
36767       {
36768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36769       };
36770     }
36771   }
36772
36773   jresult = (void *)result;
36774   return jresult;
36775 }
36776
36777
36778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36779   void * jresult ;
36780   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36781   Dali::Actor::WheelEventSignalType *result = 0 ;
36782
36783   arg1 = (Dali::Actor *)jarg1;
36784   {
36785     try {
36786       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36787     } catch (std::out_of_range& e) {
36788       {
36789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36790       };
36791     } catch (std::exception& e) {
36792       {
36793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36794       };
36795     } catch (Dali::DaliException e) {
36796       {
36797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36798       };
36799     } catch (...) {
36800       {
36801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36802       };
36803     }
36804   }
36805
36806   jresult = (void *)result;
36807   return jresult;
36808 }
36809
36810
36811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
36812   void * jresult ;
36813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36814   Dali::Actor::OnStageSignalType *result = 0 ;
36815
36816   arg1 = (Dali::Actor *)jarg1;
36817   {
36818     try {
36819       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
36820     } catch (std::out_of_range& e) {
36821       {
36822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36823       };
36824     } catch (std::exception& e) {
36825       {
36826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36827       };
36828     } catch (Dali::DaliException e) {
36829       {
36830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36831       };
36832     } catch (...) {
36833       {
36834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36835       };
36836     }
36837   }
36838
36839   jresult = (void *)result;
36840   return jresult;
36841 }
36842
36843
36844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
36845   void * jresult ;
36846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36847   Dali::Actor::OffStageSignalType *result = 0 ;
36848
36849   arg1 = (Dali::Actor *)jarg1;
36850   {
36851     try {
36852       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
36853     } catch (std::out_of_range& e) {
36854       {
36855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36856       };
36857     } catch (std::exception& e) {
36858       {
36859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36860       };
36861     } catch (Dali::DaliException e) {
36862       {
36863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36864       };
36865     } catch (...) {
36866       {
36867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36868       };
36869     }
36870   }
36871
36872   jresult = (void *)result;
36873   return jresult;
36874 }
36875
36876
36877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36878   void * jresult ;
36879   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36880   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36881
36882   arg1 = (Dali::Actor *)jarg1;
36883   {
36884     try {
36885       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36886     } catch (std::out_of_range& e) {
36887       {
36888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36889       };
36890     } catch (std::exception& e) {
36891       {
36892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36893       };
36894     } catch (Dali::DaliException e) {
36895       {
36896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36897       };
36898     } catch (...) {
36899       {
36900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36901       };
36902     }
36903   }
36904
36905   jresult = (void *)result;
36906   return jresult;
36907 }
36908
36909
36910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
36911   Dali::Actor *arg1 = 0 ;
36912
36913   arg1 = (Dali::Actor *)jarg1;
36914   if (!arg1) {
36915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36916     return ;
36917   }
36918   {
36919     try {
36920       Dali::UnparentAndReset(*arg1);
36921     } catch (std::out_of_range& e) {
36922       {
36923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36924       };
36925     } catch (std::exception& e) {
36926       {
36927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36928       };
36929     } catch (Dali::DaliException e) {
36930       {
36931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36932       };
36933     } catch (...) {
36934       {
36935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36936       };
36937     }
36938   }
36939
36940 }
36941
36942
36943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
36944   int jresult ;
36945   int result;
36946
36947   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
36948   jresult = (int)result;
36949   return jresult;
36950 }
36951
36952
36953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
36954   int jresult ;
36955   int result;
36956
36957   result = (int)Dali::Layer::Property::CLIPPING_BOX;
36958   jresult = (int)result;
36959   return jresult;
36960 }
36961
36962
36963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
36964   int jresult ;
36965   int result;
36966
36967   result = (int)Dali::Layer::Property::BEHAVIOR;
36968   jresult = (int)result;
36969   return jresult;
36970 }
36971
36972
36973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
36974   void * jresult ;
36975   Dali::Layer::Property *result = 0 ;
36976
36977   {
36978     try {
36979       result = (Dali::Layer::Property *)new Dali::Layer::Property();
36980     } catch (std::out_of_range& e) {
36981       {
36982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36983       };
36984     } catch (std::exception& e) {
36985       {
36986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36987       };
36988     } catch (Dali::DaliException e) {
36989       {
36990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36991       };
36992     } catch (...) {
36993       {
36994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36995       };
36996     }
36997   }
36998
36999   jresult = (void *)result;
37000   return jresult;
37001 }
37002
37003
37004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37005   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37006
37007   arg1 = (Dali::Layer::Property *)jarg1;
37008   {
37009     try {
37010       delete arg1;
37011     } catch (std::out_of_range& e) {
37012       {
37013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37014       };
37015     } catch (std::exception& e) {
37016       {
37017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37018       };
37019     } catch (Dali::DaliException e) {
37020       {
37021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37022       };
37023     } catch (...) {
37024       {
37025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37026       };
37027     }
37028   }
37029
37030 }
37031
37032
37033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37034   void * jresult ;
37035   Dali::Layer *result = 0 ;
37036
37037   {
37038     try {
37039       result = (Dali::Layer *)new Dali::Layer();
37040     } catch (std::out_of_range& e) {
37041       {
37042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37043       };
37044     } catch (std::exception& e) {
37045       {
37046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37047       };
37048     } catch (Dali::DaliException e) {
37049       {
37050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37051       };
37052     } catch (...) {
37053       {
37054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37055       };
37056     }
37057   }
37058
37059   jresult = (void *)result;
37060   return jresult;
37061 }
37062
37063
37064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37065   void * jresult ;
37066   Dali::Layer result;
37067
37068   {
37069     try {
37070       result = Dali::Layer::New();
37071     } catch (std::out_of_range& e) {
37072       {
37073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37074       };
37075     } catch (std::exception& e) {
37076       {
37077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37078       };
37079     } catch (Dali::DaliException e) {
37080       {
37081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37082       };
37083     } catch (...) {
37084       {
37085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37086       };
37087     }
37088   }
37089
37090   jresult = new Dali::Layer((const Dali::Layer &)result);
37091   return jresult;
37092 }
37093
37094
37095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37096   void * jresult ;
37097   Dali::BaseHandle arg1 ;
37098   Dali::BaseHandle *argp1 ;
37099   Dali::Layer result;
37100
37101   argp1 = (Dali::BaseHandle *)jarg1;
37102   if (!argp1) {
37103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37104     return 0;
37105   }
37106   arg1 = *argp1;
37107   {
37108     try {
37109       result = Dali::Layer::DownCast(arg1);
37110     } catch (std::out_of_range& e) {
37111       {
37112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37113       };
37114     } catch (std::exception& e) {
37115       {
37116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37117       };
37118     } catch (Dali::DaliException e) {
37119       {
37120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37121       };
37122     } catch (...) {
37123       {
37124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37125       };
37126     }
37127   }
37128
37129   jresult = new Dali::Layer((const Dali::Layer &)result);
37130   return jresult;
37131 }
37132
37133
37134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37135   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37136
37137   arg1 = (Dali::Layer *)jarg1;
37138   {
37139     try {
37140       delete arg1;
37141     } catch (std::out_of_range& e) {
37142       {
37143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37144       };
37145     } catch (std::exception& e) {
37146       {
37147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37148       };
37149     } catch (Dali::DaliException e) {
37150       {
37151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37152       };
37153     } catch (...) {
37154       {
37155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37156       };
37157     }
37158   }
37159
37160 }
37161
37162
37163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37164   void * jresult ;
37165   Dali::Layer *arg1 = 0 ;
37166   Dali::Layer *result = 0 ;
37167
37168   arg1 = (Dali::Layer *)jarg1;
37169   if (!arg1) {
37170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37171     return 0;
37172   }
37173   {
37174     try {
37175       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37176     } catch (std::out_of_range& e) {
37177       {
37178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37179       };
37180     } catch (std::exception& e) {
37181       {
37182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37183       };
37184     } catch (Dali::DaliException e) {
37185       {
37186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37187       };
37188     } catch (...) {
37189       {
37190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37191       };
37192     }
37193   }
37194
37195   jresult = (void *)result;
37196   return jresult;
37197 }
37198
37199
37200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37201   void * jresult ;
37202   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37203   Dali::Layer *arg2 = 0 ;
37204   Dali::Layer *result = 0 ;
37205
37206   arg1 = (Dali::Layer *)jarg1;
37207   arg2 = (Dali::Layer *)jarg2;
37208   if (!arg2) {
37209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37210     return 0;
37211   }
37212   {
37213     try {
37214       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37215     } catch (std::out_of_range& e) {
37216       {
37217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37218       };
37219     } catch (std::exception& e) {
37220       {
37221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37222       };
37223     } catch (Dali::DaliException e) {
37224       {
37225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37226       };
37227     } catch (...) {
37228       {
37229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37230       };
37231     }
37232   }
37233
37234   jresult = (void *)result;
37235   return jresult;
37236 }
37237
37238
37239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37240   unsigned int jresult ;
37241   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37242   unsigned int result;
37243
37244   arg1 = (Dali::Layer *)jarg1;
37245   {
37246     try {
37247       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37248     } catch (std::out_of_range& e) {
37249       {
37250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37251       };
37252     } catch (std::exception& e) {
37253       {
37254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37255       };
37256     } catch (Dali::DaliException e) {
37257       {
37258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37259       };
37260     } catch (...) {
37261       {
37262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37263       };
37264     }
37265   }
37266
37267   jresult = result;
37268   return jresult;
37269 }
37270
37271
37272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37273   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37274
37275   arg1 = (Dali::Layer *)jarg1;
37276   {
37277     try {
37278       (arg1)->Raise();
37279     } catch (std::out_of_range& e) {
37280       {
37281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37282       };
37283     } catch (std::exception& e) {
37284       {
37285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37286       };
37287     } catch (Dali::DaliException e) {
37288       {
37289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37290       };
37291     } catch (...) {
37292       {
37293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37294       };
37295     }
37296   }
37297
37298 }
37299
37300
37301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37302   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37303
37304   arg1 = (Dali::Layer *)jarg1;
37305   {
37306     try {
37307       (arg1)->Lower();
37308     } catch (std::out_of_range& e) {
37309       {
37310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37311       };
37312     } catch (std::exception& e) {
37313       {
37314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37315       };
37316     } catch (Dali::DaliException e) {
37317       {
37318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37319       };
37320     } catch (...) {
37321       {
37322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37323       };
37324     }
37325   }
37326
37327 }
37328
37329
37330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37331   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37332   Dali::Layer arg2 ;
37333   Dali::Layer *argp2 ;
37334
37335   arg1 = (Dali::Layer *)jarg1;
37336   argp2 = (Dali::Layer *)jarg2;
37337   if (!argp2) {
37338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37339     return ;
37340   }
37341   arg2 = *argp2;
37342   {
37343     try {
37344       (arg1)->RaiseAbove(arg2);
37345     } catch (std::out_of_range& e) {
37346       {
37347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37348       };
37349     } catch (std::exception& e) {
37350       {
37351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37352       };
37353     } catch (Dali::DaliException e) {
37354       {
37355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37356       };
37357     } catch (...) {
37358       {
37359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37360       };
37361     }
37362   }
37363
37364 }
37365
37366
37367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37368   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37369   Dali::Layer arg2 ;
37370   Dali::Layer *argp2 ;
37371
37372   arg1 = (Dali::Layer *)jarg1;
37373   argp2 = (Dali::Layer *)jarg2;
37374   if (!argp2) {
37375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37376     return ;
37377   }
37378   arg2 = *argp2;
37379   {
37380     try {
37381       (arg1)->LowerBelow(arg2);
37382     } catch (std::out_of_range& e) {
37383       {
37384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37385       };
37386     } catch (std::exception& e) {
37387       {
37388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37389       };
37390     } catch (Dali::DaliException e) {
37391       {
37392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37393       };
37394     } catch (...) {
37395       {
37396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37397       };
37398     }
37399   }
37400
37401 }
37402
37403
37404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37405   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37406
37407   arg1 = (Dali::Layer *)jarg1;
37408   {
37409     try {
37410       (arg1)->RaiseToTop();
37411     } catch (std::out_of_range& e) {
37412       {
37413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37414       };
37415     } catch (std::exception& e) {
37416       {
37417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37418       };
37419     } catch (Dali::DaliException e) {
37420       {
37421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37422       };
37423     } catch (...) {
37424       {
37425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37426       };
37427     }
37428   }
37429
37430 }
37431
37432
37433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37434   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37435
37436   arg1 = (Dali::Layer *)jarg1;
37437   {
37438     try {
37439       (arg1)->LowerToBottom();
37440     } catch (std::out_of_range& e) {
37441       {
37442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37443       };
37444     } catch (std::exception& e) {
37445       {
37446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37447       };
37448     } catch (Dali::DaliException e) {
37449       {
37450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37451       };
37452     } catch (...) {
37453       {
37454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37455       };
37456     }
37457   }
37458
37459 }
37460
37461
37462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37463   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37464   Dali::Layer arg2 ;
37465   Dali::Layer *argp2 ;
37466
37467   arg1 = (Dali::Layer *)jarg1;
37468   argp2 = (Dali::Layer *)jarg2;
37469   if (!argp2) {
37470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37471     return ;
37472   }
37473   arg2 = *argp2;
37474   {
37475     try {
37476       (arg1)->MoveAbove(arg2);
37477     } catch (std::out_of_range& e) {
37478       {
37479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37480       };
37481     } catch (std::exception& e) {
37482       {
37483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37484       };
37485     } catch (Dali::DaliException e) {
37486       {
37487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37488       };
37489     } catch (...) {
37490       {
37491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37492       };
37493     }
37494   }
37495
37496 }
37497
37498
37499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37500   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37501   Dali::Layer arg2 ;
37502   Dali::Layer *argp2 ;
37503
37504   arg1 = (Dali::Layer *)jarg1;
37505   argp2 = (Dali::Layer *)jarg2;
37506   if (!argp2) {
37507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37508     return ;
37509   }
37510   arg2 = *argp2;
37511   {
37512     try {
37513       (arg1)->MoveBelow(arg2);
37514     } catch (std::out_of_range& e) {
37515       {
37516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37517       };
37518     } catch (std::exception& e) {
37519       {
37520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37521       };
37522     } catch (Dali::DaliException e) {
37523       {
37524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37525       };
37526     } catch (...) {
37527       {
37528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37529       };
37530     }
37531   }
37532
37533 }
37534
37535
37536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37537   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37538   Dali::Layer::Behavior arg2 ;
37539
37540   arg1 = (Dali::Layer *)jarg1;
37541   arg2 = (Dali::Layer::Behavior)jarg2;
37542   {
37543     try {
37544       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37545     } catch (std::out_of_range& e) {
37546       {
37547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37548       };
37549     } catch (std::exception& e) {
37550       {
37551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37552       };
37553     } catch (Dali::DaliException e) {
37554       {
37555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37556       };
37557     } catch (...) {
37558       {
37559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37560       };
37561     }
37562   }
37563
37564 }
37565
37566
37567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37568   int jresult ;
37569   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37570   Dali::Layer::Behavior result;
37571
37572   arg1 = (Dali::Layer *)jarg1;
37573   {
37574     try {
37575       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37576     } catch (std::out_of_range& e) {
37577       {
37578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37579       };
37580     } catch (std::exception& e) {
37581       {
37582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37583       };
37584     } catch (Dali::DaliException e) {
37585       {
37586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37587       };
37588     } catch (...) {
37589       {
37590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37591       };
37592     }
37593   }
37594
37595   jresult = (int)result;
37596   return jresult;
37597 }
37598
37599
37600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37601   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37602   bool arg2 ;
37603
37604   arg1 = (Dali::Layer *)jarg1;
37605   arg2 = jarg2 ? true : false;
37606   {
37607     try {
37608       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37609     } catch (std::out_of_range& e) {
37610       {
37611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37612       };
37613     } catch (std::exception& e) {
37614       {
37615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37616       };
37617     } catch (Dali::DaliException e) {
37618       {
37619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37620       };
37621     } catch (...) {
37622       {
37623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37624       };
37625     }
37626   }
37627
37628 }
37629
37630
37631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37632   unsigned int jresult ;
37633   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37634   bool result;
37635
37636   arg1 = (Dali::Layer *)jarg1;
37637   {
37638     try {
37639       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37640     } catch (std::out_of_range& e) {
37641       {
37642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37643       };
37644     } catch (std::exception& e) {
37645       {
37646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37647       };
37648     } catch (Dali::DaliException e) {
37649       {
37650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37651       };
37652     } catch (...) {
37653       {
37654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37655       };
37656     }
37657   }
37658
37659   jresult = result;
37660   return jresult;
37661 }
37662
37663
37664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37665   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37666   int arg2 ;
37667   int arg3 ;
37668   int arg4 ;
37669   int arg5 ;
37670
37671   arg1 = (Dali::Layer *)jarg1;
37672   arg2 = (int)jarg2;
37673   arg3 = (int)jarg3;
37674   arg4 = (int)jarg4;
37675   arg5 = (int)jarg5;
37676   {
37677     try {
37678       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37679     } catch (std::out_of_range& e) {
37680       {
37681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37682       };
37683     } catch (std::exception& e) {
37684       {
37685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37686       };
37687     } catch (Dali::DaliException e) {
37688       {
37689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37690       };
37691     } catch (...) {
37692       {
37693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37694       };
37695     }
37696   }
37697
37698 }
37699
37700
37701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37702   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37703   Dali::ClippingBox arg2 ;
37704   Dali::ClippingBox *argp2 ;
37705
37706   arg1 = (Dali::Layer *)jarg1;
37707   argp2 = (Dali::ClippingBox *)jarg2;
37708   if (!argp2) {
37709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37710     return ;
37711   }
37712   arg2 = *argp2;
37713   {
37714     try {
37715       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37716     } catch (std::out_of_range& e) {
37717       {
37718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37719       };
37720     } catch (std::exception& e) {
37721       {
37722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37723       };
37724     } catch (Dali::DaliException e) {
37725       {
37726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37727       };
37728     } catch (...) {
37729       {
37730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37731       };
37732     }
37733   }
37734
37735 }
37736
37737
37738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37739   void * jresult ;
37740   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37741   Dali::ClippingBox result;
37742
37743   arg1 = (Dali::Layer *)jarg1;
37744   {
37745     try {
37746       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37747     } catch (std::out_of_range& e) {
37748       {
37749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37750       };
37751     } catch (std::exception& e) {
37752       {
37753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37754       };
37755     } catch (Dali::DaliException e) {
37756       {
37757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37758       };
37759     } catch (...) {
37760       {
37761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37762       };
37763     }
37764   }
37765
37766   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37767   return jresult;
37768 }
37769
37770
37771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37772   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37773   bool arg2 ;
37774
37775   arg1 = (Dali::Layer *)jarg1;
37776   arg2 = jarg2 ? true : false;
37777   {
37778     try {
37779       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37780     } catch (std::out_of_range& e) {
37781       {
37782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37783       };
37784     } catch (std::exception& e) {
37785       {
37786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37787       };
37788     } catch (Dali::DaliException e) {
37789       {
37790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37791       };
37792     } catch (...) {
37793       {
37794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37795       };
37796     }
37797   }
37798
37799 }
37800
37801
37802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37803   unsigned int jresult ;
37804   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37805   bool result;
37806
37807   arg1 = (Dali::Layer *)jarg1;
37808   {
37809     try {
37810       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37811     } catch (std::out_of_range& e) {
37812       {
37813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37814       };
37815     } catch (std::exception& e) {
37816       {
37817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37818       };
37819     } catch (Dali::DaliException e) {
37820       {
37821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37822       };
37823     } catch (...) {
37824       {
37825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37826       };
37827     }
37828   }
37829
37830   jresult = result;
37831   return jresult;
37832 }
37833
37834
37835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37836   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37837   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37838
37839   arg1 = (Dali::Layer *)jarg1;
37840   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37841   {
37842     try {
37843       (arg1)->SetSortFunction(arg2);
37844     } catch (std::out_of_range& e) {
37845       {
37846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37847       };
37848     } catch (std::exception& e) {
37849       {
37850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37851       };
37852     } catch (Dali::DaliException e) {
37853       {
37854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37855       };
37856     } catch (...) {
37857       {
37858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37859       };
37860     }
37861   }
37862
37863 }
37864
37865
37866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37867   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37868   bool arg2 ;
37869
37870   arg1 = (Dali::Layer *)jarg1;
37871   arg2 = jarg2 ? true : false;
37872   {
37873     try {
37874       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
37875     } catch (std::out_of_range& e) {
37876       {
37877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37878       };
37879     } catch (std::exception& e) {
37880       {
37881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37882       };
37883     } catch (Dali::DaliException e) {
37884       {
37885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37886       };
37887     } catch (...) {
37888       {
37889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37890       };
37891     }
37892   }
37893
37894 }
37895
37896
37897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
37898   unsigned int jresult ;
37899   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37900   bool result;
37901
37902   arg1 = (Dali::Layer *)jarg1;
37903   {
37904     try {
37905       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
37906     } catch (std::out_of_range& e) {
37907       {
37908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37909       };
37910     } catch (std::exception& e) {
37911       {
37912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37913       };
37914     } catch (Dali::DaliException e) {
37915       {
37916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37917       };
37918     } catch (...) {
37919       {
37920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37921       };
37922     }
37923   }
37924
37925   jresult = result;
37926   return jresult;
37927 }
37928
37929
37930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
37931   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37932   bool arg2 ;
37933
37934   arg1 = (Dali::Layer *)jarg1;
37935   arg2 = jarg2 ? true : false;
37936   {
37937     try {
37938       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
37939     } catch (std::out_of_range& e) {
37940       {
37941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37942       };
37943     } catch (std::exception& e) {
37944       {
37945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37946       };
37947     } catch (Dali::DaliException e) {
37948       {
37949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37950       };
37951     } catch (...) {
37952       {
37953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37954       };
37955     }
37956   }
37957
37958 }
37959
37960
37961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
37962   unsigned int jresult ;
37963   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37964   bool result;
37965
37966   arg1 = (Dali::Layer *)jarg1;
37967   {
37968     try {
37969       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
37970     } catch (std::out_of_range& e) {
37971       {
37972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37973       };
37974     } catch (std::exception& e) {
37975       {
37976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37977       };
37978     } catch (Dali::DaliException e) {
37979       {
37980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37981       };
37982     } catch (...) {
37983       {
37984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37985       };
37986     }
37987   }
37988
37989   jresult = result;
37990   return jresult;
37991 }
37992
37993
37994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
37995   void * jresult ;
37996   Dali::Vector4 *result = 0 ;
37997
37998   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
37999   jresult = (void *)result;
38000   return jresult;
38001 }
38002
38003
38004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38005   void * jresult ;
38006   Dali::Vector4 *result = 0 ;
38007
38008   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38009   jresult = (void *)result;
38010   return jresult;
38011 }
38012
38013
38014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38015   void * jresult ;
38016   Dali::Stage *result = 0 ;
38017
38018   {
38019     try {
38020       result = (Dali::Stage *)new Dali::Stage();
38021     } catch (std::out_of_range& e) {
38022       {
38023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38024       };
38025     } catch (std::exception& e) {
38026       {
38027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38028       };
38029     } catch (Dali::DaliException e) {
38030       {
38031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38032       };
38033     } catch (...) {
38034       {
38035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38036       };
38037     }
38038   }
38039
38040   jresult = (void *)result;
38041   return jresult;
38042 }
38043
38044
38045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38046   void * jresult ;
38047   Dali::Stage result;
38048
38049   {
38050     try {
38051       result = Dali::Stage::GetCurrent();
38052     } catch (std::out_of_range& e) {
38053       {
38054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38055       };
38056     } catch (std::exception& e) {
38057       {
38058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38059       };
38060     } catch (Dali::DaliException e) {
38061       {
38062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38063       };
38064     } catch (...) {
38065       {
38066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38067       };
38068     }
38069   }
38070
38071   jresult = new Dali::Stage((const Dali::Stage &)result);
38072   return jresult;
38073 }
38074
38075
38076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38077   unsigned int jresult ;
38078   bool result;
38079
38080   {
38081     try {
38082       result = (bool)Dali::Stage::IsInstalled();
38083     } catch (std::out_of_range& e) {
38084       {
38085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38086       };
38087     } catch (std::exception& e) {
38088       {
38089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38090       };
38091     } catch (Dali::DaliException e) {
38092       {
38093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38094       };
38095     } catch (...) {
38096       {
38097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38098       };
38099     }
38100   }
38101
38102   jresult = result;
38103   return jresult;
38104 }
38105
38106
38107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38108   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38109
38110   arg1 = (Dali::Stage *)jarg1;
38111   {
38112     try {
38113       delete arg1;
38114     } catch (std::out_of_range& e) {
38115       {
38116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38117       };
38118     } catch (std::exception& e) {
38119       {
38120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38121       };
38122     } catch (Dali::DaliException e) {
38123       {
38124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38125       };
38126     } catch (...) {
38127       {
38128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38129       };
38130     }
38131   }
38132
38133 }
38134
38135
38136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38137   void * jresult ;
38138   Dali::Stage *arg1 = 0 ;
38139   Dali::Stage *result = 0 ;
38140
38141   arg1 = (Dali::Stage *)jarg1;
38142   if (!arg1) {
38143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38144     return 0;
38145   }
38146   {
38147     try {
38148       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38149     } catch (std::out_of_range& e) {
38150       {
38151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38152       };
38153     } catch (std::exception& e) {
38154       {
38155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38156       };
38157     } catch (Dali::DaliException e) {
38158       {
38159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38160       };
38161     } catch (...) {
38162       {
38163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38164       };
38165     }
38166   }
38167
38168   jresult = (void *)result;
38169   return jresult;
38170 }
38171
38172
38173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38174   void * jresult ;
38175   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38176   Dali::Stage *arg2 = 0 ;
38177   Dali::Stage *result = 0 ;
38178
38179   arg1 = (Dali::Stage *)jarg1;
38180   arg2 = (Dali::Stage *)jarg2;
38181   if (!arg2) {
38182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38183     return 0;
38184   }
38185   {
38186     try {
38187       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38188     } catch (std::out_of_range& e) {
38189       {
38190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38191       };
38192     } catch (std::exception& e) {
38193       {
38194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38195       };
38196     } catch (Dali::DaliException e) {
38197       {
38198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38199       };
38200     } catch (...) {
38201       {
38202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38203       };
38204     }
38205   }
38206
38207   jresult = (void *)result;
38208   return jresult;
38209 }
38210
38211
38212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38213   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38214   Dali::Actor *arg2 = 0 ;
38215
38216   arg1 = (Dali::Stage *)jarg1;
38217   arg2 = (Dali::Actor *)jarg2;
38218   if (!arg2) {
38219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38220     return ;
38221   }
38222   {
38223     try {
38224       (arg1)->Add(*arg2);
38225     } catch (std::out_of_range& e) {
38226       {
38227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38228       };
38229     } catch (std::exception& e) {
38230       {
38231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38232       };
38233     } catch (Dali::DaliException e) {
38234       {
38235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38236       };
38237     } catch (...) {
38238       {
38239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38240       };
38241     }
38242   }
38243
38244 }
38245
38246
38247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38248   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38249   Dali::Actor *arg2 = 0 ;
38250
38251   arg1 = (Dali::Stage *)jarg1;
38252   arg2 = (Dali::Actor *)jarg2;
38253   if (!arg2) {
38254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38255     return ;
38256   }
38257   {
38258     try {
38259       (arg1)->Remove(*arg2);
38260     } catch (std::out_of_range& e) {
38261       {
38262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38263       };
38264     } catch (std::exception& e) {
38265       {
38266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38267       };
38268     } catch (Dali::DaliException e) {
38269       {
38270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38271       };
38272     } catch (...) {
38273       {
38274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38275       };
38276     }
38277   }
38278
38279 }
38280
38281
38282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38283   void * jresult ;
38284   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38285   Dali::Vector2 result;
38286
38287   arg1 = (Dali::Stage *)jarg1;
38288   {
38289     try {
38290       result = ((Dali::Stage const *)arg1)->GetSize();
38291     } catch (std::out_of_range& e) {
38292       {
38293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38294       };
38295     } catch (std::exception& e) {
38296       {
38297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38298       };
38299     } catch (Dali::DaliException e) {
38300       {
38301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38302       };
38303     } catch (...) {
38304       {
38305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38306       };
38307     }
38308   }
38309
38310   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38311   return jresult;
38312 }
38313
38314
38315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38316   void * jresult ;
38317   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38318   Dali::RenderTaskList result;
38319
38320   arg1 = (Dali::Stage *)jarg1;
38321   {
38322     try {
38323       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38324     } catch (std::out_of_range& e) {
38325       {
38326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38327       };
38328     } catch (std::exception& e) {
38329       {
38330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38331       };
38332     } catch (Dali::DaliException e) {
38333       {
38334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38335       };
38336     } catch (...) {
38337       {
38338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38339       };
38340     }
38341   }
38342
38343   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38344   return jresult;
38345 }
38346
38347
38348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38349   unsigned int jresult ;
38350   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38351   unsigned int result;
38352
38353   arg1 = (Dali::Stage *)jarg1;
38354   {
38355     try {
38356       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38357     } catch (std::out_of_range& e) {
38358       {
38359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38360       };
38361     } catch (std::exception& e) {
38362       {
38363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (Dali::DaliException e) {
38366       {
38367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38368       };
38369     } catch (...) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38372       };
38373     }
38374   }
38375
38376   jresult = result;
38377   return jresult;
38378 }
38379
38380
38381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38382   void * jresult ;
38383   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38384   unsigned int arg2 ;
38385   Dali::Layer result;
38386
38387   arg1 = (Dali::Stage *)jarg1;
38388   arg2 = (unsigned int)jarg2;
38389   {
38390     try {
38391       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38392     } catch (std::out_of_range& e) {
38393       {
38394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38395       };
38396     } catch (std::exception& e) {
38397       {
38398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38399       };
38400     } catch (Dali::DaliException e) {
38401       {
38402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38403       };
38404     } catch (...) {
38405       {
38406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38407       };
38408     }
38409   }
38410
38411   jresult = new Dali::Layer((const Dali::Layer &)result);
38412   return jresult;
38413 }
38414
38415
38416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38417   void * jresult ;
38418   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38419   Dali::Layer result;
38420
38421   arg1 = (Dali::Stage *)jarg1;
38422   {
38423     try {
38424       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38425     } catch (std::out_of_range& e) {
38426       {
38427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38428       };
38429     } catch (std::exception& e) {
38430       {
38431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38432       };
38433     } catch (Dali::DaliException e) {
38434       {
38435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38436       };
38437     } catch (...) {
38438       {
38439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38440       };
38441     }
38442   }
38443
38444   jresult = new Dali::Layer((const Dali::Layer &)result);
38445   return jresult;
38446 }
38447
38448
38449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38450   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38451   Dali::Vector4 arg2 ;
38452   Dali::Vector4 *argp2 ;
38453
38454   arg1 = (Dali::Stage *)jarg1;
38455   argp2 = (Dali::Vector4 *)jarg2;
38456   if (!argp2) {
38457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38458     return ;
38459   }
38460   arg2 = *argp2;
38461   {
38462     try {
38463       (arg1)->SetBackgroundColor(arg2);
38464     } catch (std::out_of_range& e) {
38465       {
38466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38467       };
38468     } catch (std::exception& e) {
38469       {
38470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38471       };
38472     } catch (Dali::DaliException e) {
38473       {
38474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38475       };
38476     } catch (...) {
38477       {
38478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38479       };
38480     }
38481   }
38482
38483 }
38484
38485
38486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38487   void * jresult ;
38488   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38489   Dali::Vector4 result;
38490
38491   arg1 = (Dali::Stage *)jarg1;
38492   {
38493     try {
38494       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38495     } catch (std::out_of_range& e) {
38496       {
38497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38498       };
38499     } catch (std::exception& e) {
38500       {
38501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38502       };
38503     } catch (Dali::DaliException e) {
38504       {
38505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38506       };
38507     } catch (...) {
38508       {
38509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38510       };
38511     }
38512   }
38513
38514   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38515   return jresult;
38516 }
38517
38518
38519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38520   void * jresult ;
38521   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38522   Dali::Vector2 result;
38523
38524   arg1 = (Dali::Stage *)jarg1;
38525   {
38526     try {
38527       result = ((Dali::Stage const *)arg1)->GetDpi();
38528     } catch (std::out_of_range& e) {
38529       {
38530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38531       };
38532     } catch (std::exception& e) {
38533       {
38534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38535       };
38536     } catch (Dali::DaliException e) {
38537       {
38538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38539       };
38540     } catch (...) {
38541       {
38542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38543       };
38544     }
38545   }
38546
38547   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38548   return jresult;
38549 }
38550
38551
38552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38553   void * jresult ;
38554   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38555   Dali::ObjectRegistry result;
38556
38557   arg1 = (Dali::Stage *)jarg1;
38558   {
38559     try {
38560       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38561     } catch (std::out_of_range& e) {
38562       {
38563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38564       };
38565     } catch (std::exception& e) {
38566       {
38567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38568       };
38569     } catch (Dali::DaliException e) {
38570       {
38571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38572       };
38573     } catch (...) {
38574       {
38575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38576       };
38577     }
38578   }
38579
38580   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38581   return jresult;
38582 }
38583
38584
38585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38586   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38587   float arg2 ;
38588
38589   arg1 = (Dali::Stage *)jarg1;
38590   arg2 = (float)jarg2;
38591   {
38592     try {
38593       (arg1)->KeepRendering(arg2);
38594     } catch (std::out_of_range& e) {
38595       {
38596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38597       };
38598     } catch (std::exception& e) {
38599       {
38600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38601       };
38602     } catch (Dali::DaliException e) {
38603       {
38604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38605       };
38606     } catch (...) {
38607       {
38608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38609       };
38610     }
38611   }
38612
38613 }
38614
38615
38616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38617   void * jresult ;
38618   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38619   Dali::Stage::KeyEventSignalType *result = 0 ;
38620
38621   arg1 = (Dali::Stage *)jarg1;
38622   {
38623     try {
38624       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38625     } catch (std::out_of_range& e) {
38626       {
38627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38628       };
38629     } catch (std::exception& e) {
38630       {
38631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38632       };
38633     } catch (Dali::DaliException e) {
38634       {
38635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38636       };
38637     } catch (...) {
38638       {
38639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38640       };
38641     }
38642   }
38643
38644   jresult = (void *)result;
38645   return jresult;
38646 }
38647
38648
38649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38650   void * jresult ;
38651   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38652   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38653
38654   arg1 = (Dali::Stage *)jarg1;
38655   {
38656     try {
38657       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38658     } catch (std::out_of_range& e) {
38659       {
38660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38661       };
38662     } catch (std::exception& e) {
38663       {
38664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38665       };
38666     } catch (Dali::DaliException e) {
38667       {
38668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38669       };
38670     } catch (...) {
38671       {
38672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38673       };
38674     }
38675   }
38676
38677   jresult = (void *)result;
38678   return jresult;
38679 }
38680
38681
38682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38683   void * jresult ;
38684   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38685   Dali::Stage::TouchSignalType *result = 0 ;
38686
38687   arg1 = (Dali::Stage *)jarg1;
38688   {
38689     try {
38690       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38691     } catch (std::out_of_range& e) {
38692       {
38693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38694       };
38695     } catch (std::exception& e) {
38696       {
38697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38698       };
38699     } catch (Dali::DaliException e) {
38700       {
38701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38702       };
38703     } catch (...) {
38704       {
38705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38706       };
38707     }
38708   }
38709
38710   jresult = (void *)result;
38711   return jresult;
38712 }
38713
38714
38715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38716   void * jresult ;
38717   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38718   Dali::Stage::WheelEventSignalType *result = 0 ;
38719
38720   arg1 = (Dali::Stage *)jarg1;
38721   {
38722     try {
38723       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38724     } catch (std::out_of_range& e) {
38725       {
38726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38727       };
38728     } catch (std::exception& e) {
38729       {
38730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38731       };
38732     } catch (Dali::DaliException e) {
38733       {
38734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38735       };
38736     } catch (...) {
38737       {
38738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38739       };
38740     }
38741   }
38742
38743   jresult = (void *)result;
38744   return jresult;
38745 }
38746
38747
38748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38749   void * jresult ;
38750   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38751   Dali::Stage::ContextStatusSignal *result = 0 ;
38752
38753   arg1 = (Dali::Stage *)jarg1;
38754   {
38755     try {
38756       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38757     } catch (std::out_of_range& e) {
38758       {
38759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38760       };
38761     } catch (std::exception& e) {
38762       {
38763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38764       };
38765     } catch (Dali::DaliException e) {
38766       {
38767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38768       };
38769     } catch (...) {
38770       {
38771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38772       };
38773     }
38774   }
38775
38776   jresult = (void *)result;
38777   return jresult;
38778 }
38779
38780
38781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38782   void * jresult ;
38783   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38784   Dali::Stage::ContextStatusSignal *result = 0 ;
38785
38786   arg1 = (Dali::Stage *)jarg1;
38787   {
38788     try {
38789       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38790     } catch (std::out_of_range& e) {
38791       {
38792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38793       };
38794     } catch (std::exception& e) {
38795       {
38796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38797       };
38798     } catch (Dali::DaliException e) {
38799       {
38800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38801       };
38802     } catch (...) {
38803       {
38804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38805       };
38806     }
38807   }
38808
38809   jresult = (void *)result;
38810   return jresult;
38811 }
38812
38813
38814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38815   void * jresult ;
38816   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38817   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38818
38819   arg1 = (Dali::Stage *)jarg1;
38820   {
38821     try {
38822       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38823     } catch (std::out_of_range& e) {
38824       {
38825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38826       };
38827     } catch (std::exception& e) {
38828       {
38829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38830       };
38831     } catch (Dali::DaliException e) {
38832       {
38833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38834       };
38835     } catch (...) {
38836       {
38837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38838       };
38839     }
38840   }
38841
38842   jresult = (void *)result;
38843   return jresult;
38844 }
38845
38846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38847   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38848   Dali::DevelStage::Rendering arg2 ;
38849
38850   arg1 = (Dali::Stage *)jarg1;
38851   arg2 = (Dali::DevelStage::Rendering)jarg2;
38852   {
38853     try {
38854       DevelStage::SetRenderingBehavior(*arg1,arg2);
38855     } catch (std::out_of_range& e) {
38856       {
38857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38858       };
38859     } catch (std::exception& e) {
38860       {
38861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38862       };
38863     } catch (Dali::DaliException e) {
38864       {
38865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38866       };
38867     } catch (...) {
38868       {
38869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38870       };
38871     }
38872   }
38873
38874 }
38875
38876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38877
38878   int jresult ;
38879   int result ;
38880   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38881
38882   arg1 = (Dali::Stage *)jarg1;
38883   {
38884     try {
38885       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38886     } catch (std::out_of_range& e) {
38887       {
38888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38889       };
38890     } catch (std::exception& e) {
38891       {
38892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38893       };
38894     } catch (Dali::DaliException e) {
38895       {
38896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38897       };
38898     } catch (...) {
38899       {
38900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38901       };
38902     }
38903   }
38904
38905   jresult = result;
38906   return jresult;
38907 }
38908
38909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38910   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38911
38912   arg1 = (Dali::RelayoutContainer *)jarg1;
38913   {
38914     try {
38915       delete arg1;
38916     } catch (std::out_of_range& e) {
38917       {
38918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38919       };
38920     } catch (std::exception& e) {
38921       {
38922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38923       };
38924     } catch (Dali::DaliException e) {
38925       {
38926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38927       };
38928     } catch (...) {
38929       {
38930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38931       };
38932     }
38933   }
38934
38935 }
38936
38937
38938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38939   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38940   Dali::Actor *arg2 = 0 ;
38941   Dali::Vector2 *arg3 = 0 ;
38942
38943   arg1 = (Dali::RelayoutContainer *)jarg1;
38944   arg2 = (Dali::Actor *)jarg2;
38945   if (!arg2) {
38946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38947     return ;
38948   }
38949   arg3 = (Dali::Vector2 *)jarg3;
38950   if (!arg3) {
38951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38952     return ;
38953   }
38954   {
38955     try {
38956       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38957     } catch (std::out_of_range& e) {
38958       {
38959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38960       };
38961     } catch (std::exception& e) {
38962       {
38963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38964       };
38965     } catch (Dali::DaliException e) {
38966       {
38967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38968       };
38969     } catch (...) {
38970       {
38971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38972       };
38973     }
38974   }
38975
38976 }
38977
38978
38979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38980   void * jresult ;
38981   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38982   Dali::CustomActor result;
38983
38984   arg1 = (Dali::CustomActorImpl *)jarg1;
38985   {
38986     try {
38987       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38988     } catch (std::out_of_range& e) {
38989       {
38990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38991       };
38992     } catch (std::exception& e) {
38993       {
38994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38995       };
38996     } catch (Dali::DaliException e) {
38997       {
38998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38999       };
39000     } catch (...) {
39001       {
39002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39003       };
39004     }
39005   }
39006
39007   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39008   return jresult;
39009 }
39010
39011
39012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39013   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39014   int arg2 ;
39015
39016   arg1 = (Dali::CustomActorImpl *)jarg1;
39017   arg2 = (int)jarg2;
39018   {
39019     try {
39020       (arg1)->OnStageConnection(arg2);
39021     } catch (std::out_of_range& e) {
39022       {
39023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39024       };
39025     } catch (std::exception& e) {
39026       {
39027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39028       };
39029     } catch (Dali::DaliException e) {
39030       {
39031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39032       };
39033     } catch (...) {
39034       {
39035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39036       };
39037     }
39038   }
39039
39040 }
39041
39042
39043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39044   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39045
39046   arg1 = (Dali::CustomActorImpl *)jarg1;
39047   {
39048     try {
39049       (arg1)->OnStageDisconnection();
39050     } catch (std::out_of_range& e) {
39051       {
39052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39053       };
39054     } catch (std::exception& e) {
39055       {
39056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39057       };
39058     } catch (Dali::DaliException e) {
39059       {
39060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39061       };
39062     } catch (...) {
39063       {
39064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39065       };
39066     }
39067   }
39068
39069 }
39070
39071
39072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39073   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39074   Dali::Actor *arg2 = 0 ;
39075
39076   arg1 = (Dali::CustomActorImpl *)jarg1;
39077   arg2 = (Dali::Actor *)jarg2;
39078   if (!arg2) {
39079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39080     return ;
39081   }
39082   {
39083     try {
39084       (arg1)->OnChildAdd(*arg2);
39085     } catch (std::out_of_range& e) {
39086       {
39087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39088       };
39089     } catch (std::exception& e) {
39090       {
39091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39092       };
39093     } catch (Dali::DaliException e) {
39094       {
39095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39096       };
39097     } catch (...) {
39098       {
39099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39100       };
39101     }
39102   }
39103
39104 }
39105
39106
39107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39108   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39109   Dali::Actor *arg2 = 0 ;
39110
39111   arg1 = (Dali::CustomActorImpl *)jarg1;
39112   arg2 = (Dali::Actor *)jarg2;
39113   if (!arg2) {
39114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39115     return ;
39116   }
39117   {
39118     try {
39119       (arg1)->OnChildRemove(*arg2);
39120     } catch (std::out_of_range& e) {
39121       {
39122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39123       };
39124     } catch (std::exception& e) {
39125       {
39126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39127       };
39128     } catch (Dali::DaliException e) {
39129       {
39130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39131       };
39132     } catch (...) {
39133       {
39134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39135       };
39136     }
39137   }
39138
39139 }
39140
39141
39142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39143   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39144   Dali::Property::Index arg2 ;
39145   Dali::Property::Value arg3 ;
39146   Dali::Property::Value *argp3 ;
39147
39148   arg1 = (Dali::CustomActorImpl *)jarg1;
39149   arg2 = (Dali::Property::Index)jarg2;
39150   argp3 = (Dali::Property::Value *)jarg3;
39151   if (!argp3) {
39152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39153     return ;
39154   }
39155   arg3 = *argp3;
39156   {
39157     try {
39158       (arg1)->OnPropertySet(arg2,arg3);
39159     } catch (std::out_of_range& e) {
39160       {
39161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39162       };
39163     } catch (std::exception& e) {
39164       {
39165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39166       };
39167     } catch (Dali::DaliException e) {
39168       {
39169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39170       };
39171     } catch (...) {
39172       {
39173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39174       };
39175     }
39176   }
39177
39178 }
39179
39180
39181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39182   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39183   Dali::Vector3 *arg2 = 0 ;
39184
39185   arg1 = (Dali::CustomActorImpl *)jarg1;
39186   arg2 = (Dali::Vector3 *)jarg2;
39187   if (!arg2) {
39188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39189     return ;
39190   }
39191   {
39192     try {
39193       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39194     } catch (std::out_of_range& e) {
39195       {
39196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39197       };
39198     } catch (std::exception& e) {
39199       {
39200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39201       };
39202     } catch (Dali::DaliException e) {
39203       {
39204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39205       };
39206     } catch (...) {
39207       {
39208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39209       };
39210     }
39211   }
39212
39213 }
39214
39215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39216   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39217   Dali::Animation *arg2 = 0 ;
39218   Dali::Vector3 *arg3 = 0 ;
39219
39220   arg1 = (Dali::CustomActorImpl *)jarg1;
39221   arg2 = (Dali::Animation *)jarg2;
39222   if (!arg2) {
39223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39224     return ;
39225   }
39226   arg3 = (Dali::Vector3 *)jarg3;
39227   if (!arg3) {
39228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39229     return ;
39230   }
39231   {
39232     try {
39233       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39234     } catch (std::out_of_range& e) {
39235       {
39236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39237       };
39238     } catch (std::exception& e) {
39239       {
39240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39241       };
39242     } catch (Dali::DaliException e) {
39243       {
39244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39245       };
39246     } catch (...) {
39247       {
39248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39249       };
39250     }
39251   }
39252
39253 }
39254
39255
39256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39257   unsigned int jresult ;
39258   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39259   Dali::TouchEvent *arg2 = 0 ;
39260   bool result;
39261
39262   arg1 = (Dali::CustomActorImpl *)jarg1;
39263   arg2 = (Dali::TouchEvent *)jarg2;
39264   if (!arg2) {
39265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39266     return 0;
39267   }
39268   {
39269     try {
39270       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39271     } catch (std::out_of_range& e) {
39272       {
39273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39274       };
39275     } catch (std::exception& e) {
39276       {
39277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39278       };
39279     } catch (Dali::DaliException e) {
39280       {
39281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39282       };
39283     } catch (...) {
39284       {
39285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39286       };
39287     }
39288   }
39289
39290   jresult = result;
39291   return jresult;
39292 }
39293
39294
39295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39296   unsigned int jresult ;
39297   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39298   Dali::HoverEvent *arg2 = 0 ;
39299   bool result;
39300
39301   arg1 = (Dali::CustomActorImpl *)jarg1;
39302   arg2 = (Dali::HoverEvent *)jarg2;
39303   if (!arg2) {
39304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39305     return 0;
39306   }
39307   {
39308     try {
39309       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39310     } catch (std::out_of_range& e) {
39311       {
39312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39313       };
39314     } catch (std::exception& e) {
39315       {
39316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39317       };
39318     } catch (Dali::DaliException e) {
39319       {
39320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39321       };
39322     } catch (...) {
39323       {
39324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39325       };
39326     }
39327   }
39328
39329   jresult = result;
39330   return jresult;
39331 }
39332
39333
39334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39335   unsigned int jresult ;
39336   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39337   Dali::KeyEvent *arg2 = 0 ;
39338   bool result;
39339
39340   arg1 = (Dali::CustomActorImpl *)jarg1;
39341   arg2 = (Dali::KeyEvent *)jarg2;
39342   if (!arg2) {
39343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39344     return 0;
39345   }
39346   {
39347     try {
39348       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39349     } catch (std::out_of_range& e) {
39350       {
39351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39352       };
39353     } catch (std::exception& e) {
39354       {
39355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39356       };
39357     } catch (Dali::DaliException e) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39360       };
39361     } catch (...) {
39362       {
39363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39364       };
39365     }
39366   }
39367
39368   jresult = result;
39369   return jresult;
39370 }
39371
39372
39373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39374   unsigned int jresult ;
39375   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39376   Dali::WheelEvent *arg2 = 0 ;
39377   bool result;
39378
39379   arg1 = (Dali::CustomActorImpl *)jarg1;
39380   arg2 = (Dali::WheelEvent *)jarg2;
39381   if (!arg2) {
39382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39383     return 0;
39384   }
39385   {
39386     try {
39387       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39388     } catch (std::out_of_range& e) {
39389       {
39390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39391       };
39392     } catch (std::exception& e) {
39393       {
39394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39395       };
39396     } catch (Dali::DaliException e) {
39397       {
39398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39399       };
39400     } catch (...) {
39401       {
39402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39403       };
39404     }
39405   }
39406
39407   jresult = result;
39408   return jresult;
39409 }
39410
39411
39412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39413   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39414   Dali::Vector2 *arg2 = 0 ;
39415   Dali::RelayoutContainer *arg3 = 0 ;
39416
39417   arg1 = (Dali::CustomActorImpl *)jarg1;
39418   arg2 = (Dali::Vector2 *)jarg2;
39419   if (!arg2) {
39420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39421     return ;
39422   }
39423   arg3 = (Dali::RelayoutContainer *)jarg3;
39424   if (!arg3) {
39425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39426     return ;
39427   }
39428   {
39429     try {
39430       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39431     } catch (std::out_of_range& e) {
39432       {
39433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39434       };
39435     } catch (std::exception& e) {
39436       {
39437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39438       };
39439     } catch (Dali::DaliException e) {
39440       {
39441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39442       };
39443     } catch (...) {
39444       {
39445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39446       };
39447     }
39448   }
39449
39450 }
39451
39452
39453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39454   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39455   Dali::ResizePolicy::Type arg2 ;
39456   Dali::Dimension::Type arg3 ;
39457
39458   arg1 = (Dali::CustomActorImpl *)jarg1;
39459   arg2 = (Dali::ResizePolicy::Type)jarg2;
39460   arg3 = (Dali::Dimension::Type)jarg3;
39461   {
39462     try {
39463       (arg1)->OnSetResizePolicy(arg2,arg3);
39464     } catch (std::out_of_range& e) {
39465       {
39466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39467       };
39468     } catch (std::exception& e) {
39469       {
39470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39471       };
39472     } catch (Dali::DaliException e) {
39473       {
39474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39475       };
39476     } catch (...) {
39477       {
39478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39479       };
39480     }
39481   }
39482
39483 }
39484
39485
39486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39487   void * jresult ;
39488   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39489   Dali::Vector3 result;
39490
39491   arg1 = (Dali::CustomActorImpl *)jarg1;
39492   {
39493     try {
39494       result = (arg1)->GetNaturalSize();
39495     } catch (std::out_of_range& e) {
39496       {
39497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39498       };
39499     } catch (std::exception& e) {
39500       {
39501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39502       };
39503     } catch (Dali::DaliException e) {
39504       {
39505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39506       };
39507     } catch (...) {
39508       {
39509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39510       };
39511     }
39512   }
39513
39514   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39515   return jresult;
39516 }
39517
39518
39519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39520   float jresult ;
39521   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39522   Dali::Actor *arg2 = 0 ;
39523   Dali::Dimension::Type arg3 ;
39524   float result;
39525
39526   arg1 = (Dali::CustomActorImpl *)jarg1;
39527   arg2 = (Dali::Actor *)jarg2;
39528   if (!arg2) {
39529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39530     return 0;
39531   }
39532   arg3 = (Dali::Dimension::Type)jarg3;
39533   {
39534     try {
39535       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39536     } catch (std::out_of_range& e) {
39537       {
39538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39539       };
39540     } catch (std::exception& e) {
39541       {
39542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39543       };
39544     } catch (Dali::DaliException e) {
39545       {
39546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39547       };
39548     } catch (...) {
39549       {
39550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39551       };
39552     }
39553   }
39554
39555   jresult = result;
39556   return jresult;
39557 }
39558
39559
39560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39561   float jresult ;
39562   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39563   float arg2 ;
39564   float result;
39565
39566   arg1 = (Dali::CustomActorImpl *)jarg1;
39567   arg2 = (float)jarg2;
39568   {
39569     try {
39570       result = (float)(arg1)->GetHeightForWidth(arg2);
39571     } catch (std::out_of_range& e) {
39572       {
39573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39574       };
39575     } catch (std::exception& e) {
39576       {
39577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39578       };
39579     } catch (Dali::DaliException e) {
39580       {
39581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39582       };
39583     } catch (...) {
39584       {
39585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39586       };
39587     }
39588   }
39589
39590   jresult = result;
39591   return jresult;
39592 }
39593
39594
39595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39596   float jresult ;
39597   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39598   float arg2 ;
39599   float result;
39600
39601   arg1 = (Dali::CustomActorImpl *)jarg1;
39602   arg2 = (float)jarg2;
39603   {
39604     try {
39605       result = (float)(arg1)->GetWidthForHeight(arg2);
39606     } catch (std::out_of_range& e) {
39607       {
39608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39609       };
39610     } catch (std::exception& e) {
39611       {
39612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39613       };
39614     } catch (Dali::DaliException e) {
39615       {
39616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39617       };
39618     } catch (...) {
39619       {
39620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39621       };
39622     }
39623   }
39624
39625   jresult = result;
39626   return jresult;
39627 }
39628
39629
39630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39631   unsigned int jresult ;
39632   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39633   Dali::Dimension::Type arg2 ;
39634   bool result;
39635
39636   arg1 = (Dali::CustomActorImpl *)jarg1;
39637   arg2 = (Dali::Dimension::Type)jarg2;
39638   {
39639     try {
39640       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39641     } catch (std::out_of_range& e) {
39642       {
39643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39644       };
39645     } catch (std::exception& e) {
39646       {
39647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39648       };
39649     } catch (Dali::DaliException e) {
39650       {
39651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39652       };
39653     } catch (...) {
39654       {
39655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39656       };
39657     }
39658   }
39659
39660   jresult = result;
39661   return jresult;
39662 }
39663
39664
39665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39666   unsigned int jresult ;
39667   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39668   bool result;
39669
39670   arg1 = (Dali::CustomActorImpl *)jarg1;
39671   {
39672     try {
39673       result = (bool)(arg1)->RelayoutDependentOnChildren();
39674     } catch (std::out_of_range& e) {
39675       {
39676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39677       };
39678     } catch (std::exception& e) {
39679       {
39680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39681       };
39682     } catch (Dali::DaliException e) {
39683       {
39684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39685       };
39686     } catch (...) {
39687       {
39688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39689       };
39690     }
39691   }
39692
39693   jresult = result;
39694   return jresult;
39695 }
39696
39697
39698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39699   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39700   Dali::Dimension::Type arg2 ;
39701
39702   arg1 = (Dali::CustomActorImpl *)jarg1;
39703   arg2 = (Dali::Dimension::Type)jarg2;
39704   {
39705     try {
39706       (arg1)->OnCalculateRelayoutSize(arg2);
39707     } catch (std::out_of_range& e) {
39708       {
39709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39710       };
39711     } catch (std::exception& e) {
39712       {
39713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39714       };
39715     } catch (Dali::DaliException e) {
39716       {
39717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39718       };
39719     } catch (...) {
39720       {
39721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39722       };
39723     }
39724   }
39725
39726 }
39727
39728
39729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39730   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39731   float arg2 ;
39732   Dali::Dimension::Type arg3 ;
39733
39734   arg1 = (Dali::CustomActorImpl *)jarg1;
39735   arg2 = (float)jarg2;
39736   arg3 = (Dali::Dimension::Type)jarg3;
39737   {
39738     try {
39739       (arg1)->OnLayoutNegotiated(arg2,arg3);
39740     } catch (std::out_of_range& e) {
39741       {
39742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39743       };
39744     } catch (std::exception& e) {
39745       {
39746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39747       };
39748     } catch (Dali::DaliException e) {
39749       {
39750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39751       };
39752     } catch (...) {
39753       {
39754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39755       };
39756     }
39757   }
39758
39759 }
39760
39761
39762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39763   unsigned int jresult ;
39764   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39765   bool result;
39766
39767   arg1 = (Dali::CustomActorImpl *)jarg1;
39768   {
39769     try {
39770       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39771     } catch (std::out_of_range& e) {
39772       {
39773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39774       };
39775     } catch (std::exception& e) {
39776       {
39777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39778       };
39779     } catch (Dali::DaliException e) {
39780       {
39781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39782       };
39783     } catch (...) {
39784       {
39785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39786       };
39787     }
39788   }
39789
39790   jresult = result;
39791   return jresult;
39792 }
39793
39794
39795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39796   unsigned int jresult ;
39797   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39798   bool result;
39799
39800   arg1 = (Dali::CustomActorImpl *)jarg1;
39801   {
39802     try {
39803       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39804     } catch (std::out_of_range& e) {
39805       {
39806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39807       };
39808     } catch (std::exception& e) {
39809       {
39810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39811       };
39812     } catch (Dali::DaliException e) {
39813       {
39814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39815       };
39816     } catch (...) {
39817       {
39818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39819       };
39820     }
39821   }
39822
39823   jresult = result;
39824   return jresult;
39825 }
39826
39827
39828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39829   unsigned int jresult ;
39830   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39831   bool result;
39832
39833   arg1 = (Dali::CustomActorImpl *)jarg1;
39834   {
39835     try {
39836       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39837     } catch (std::out_of_range& e) {
39838       {
39839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39840       };
39841     } catch (std::exception& e) {
39842       {
39843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39844       };
39845     } catch (Dali::DaliException e) {
39846       {
39847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39848       };
39849     } catch (...) {
39850       {
39851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39852       };
39853     }
39854   }
39855
39856   jresult = result;
39857   return jresult;
39858 }
39859
39860
39861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39862   unsigned int jresult ;
39863   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39864   bool result;
39865
39866   arg1 = (Dali::CustomActorImpl *)jarg1;
39867   {
39868     try {
39869       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39870     } catch (std::out_of_range& e) {
39871       {
39872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39873       };
39874     } catch (std::exception& e) {
39875       {
39876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39877       };
39878     } catch (Dali::DaliException e) {
39879       {
39880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39881       };
39882     } catch (...) {
39883       {
39884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39885       };
39886     }
39887   }
39888
39889   jresult = result;
39890   return jresult;
39891 }
39892
39893
39894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39895   void * jresult ;
39896   Dali::CustomActor *result = 0 ;
39897
39898   {
39899     try {
39900       result = (Dali::CustomActor *)new Dali::CustomActor();
39901     } catch (std::out_of_range& e) {
39902       {
39903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39904       };
39905     } catch (std::exception& e) {
39906       {
39907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39908       };
39909     } catch (Dali::DaliException e) {
39910       {
39911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39912       };
39913     } catch (...) {
39914       {
39915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39916       };
39917     }
39918   }
39919
39920   jresult = (void *)result;
39921   return jresult;
39922 }
39923
39924
39925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39926   void * jresult ;
39927   Dali::BaseHandle arg1 ;
39928   Dali::BaseHandle *argp1 ;
39929   Dali::CustomActor result;
39930
39931   argp1 = (Dali::BaseHandle *)jarg1;
39932   if (!argp1) {
39933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39934     return 0;
39935   }
39936   arg1 = *argp1;
39937   {
39938     try {
39939       result = Dali::CustomActor::DownCast(arg1);
39940     } catch (std::out_of_range& e) {
39941       {
39942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39943       };
39944     } catch (std::exception& e) {
39945       {
39946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39947       };
39948     } catch (Dali::DaliException e) {
39949       {
39950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39951       };
39952     } catch (...) {
39953       {
39954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39955       };
39956     }
39957   }
39958
39959   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39960   return jresult;
39961 }
39962
39963
39964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39965   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39966
39967   arg1 = (Dali::CustomActor *)jarg1;
39968   {
39969     try {
39970       delete arg1;
39971     } catch (std::out_of_range& e) {
39972       {
39973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39974       };
39975     } catch (std::exception& e) {
39976       {
39977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39978       };
39979     } catch (Dali::DaliException e) {
39980       {
39981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39982       };
39983     } catch (...) {
39984       {
39985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39986       };
39987     }
39988   }
39989
39990 }
39991
39992
39993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39994   void * jresult ;
39995   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39996   Dali::CustomActorImpl *result = 0 ;
39997
39998   arg1 = (Dali::CustomActor *)jarg1;
39999   {
40000     try {
40001       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40002     } catch (std::out_of_range& e) {
40003       {
40004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40005       };
40006     } catch (std::exception& e) {
40007       {
40008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40009       };
40010     } catch (Dali::DaliException e) {
40011       {
40012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40013       };
40014     } catch (...) {
40015       {
40016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40017       };
40018     }
40019   }
40020
40021   jresult = (void *)result;
40022   return jresult;
40023 }
40024
40025
40026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40027   void * jresult ;
40028   Dali::CustomActorImpl *arg1 = 0 ;
40029   Dali::CustomActor *result = 0 ;
40030
40031   arg1 = (Dali::CustomActorImpl *)jarg1;
40032   if (!arg1) {
40033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40034     return 0;
40035   }
40036   {
40037     try {
40038       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40039     } catch (std::out_of_range& e) {
40040       {
40041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40042       };
40043     } catch (std::exception& e) {
40044       {
40045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40046       };
40047     } catch (Dali::DaliException e) {
40048       {
40049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40050       };
40051     } catch (...) {
40052       {
40053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40054       };
40055     }
40056   }
40057
40058   jresult = (void *)result;
40059   return jresult;
40060 }
40061
40062
40063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40064   void * jresult ;
40065   Dali::CustomActor *arg1 = 0 ;
40066   Dali::CustomActor *result = 0 ;
40067
40068   arg1 = (Dali::CustomActor *)jarg1;
40069   if (!arg1) {
40070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40071     return 0;
40072   }
40073   {
40074     try {
40075       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40076     } catch (std::out_of_range& e) {
40077       {
40078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40079       };
40080     } catch (std::exception& e) {
40081       {
40082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40083       };
40084     } catch (Dali::DaliException e) {
40085       {
40086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40087       };
40088     } catch (...) {
40089       {
40090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40091       };
40092     }
40093   }
40094
40095   jresult = (void *)result;
40096   return jresult;
40097 }
40098
40099
40100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40101   void * jresult ;
40102   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40103   Dali::CustomActor *arg2 = 0 ;
40104   Dali::CustomActor *result = 0 ;
40105
40106   arg1 = (Dali::CustomActor *)jarg1;
40107   arg2 = (Dali::CustomActor *)jarg2;
40108   if (!arg2) {
40109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40110     return 0;
40111   }
40112   {
40113     try {
40114       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40115     } catch (std::out_of_range& e) {
40116       {
40117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40118       };
40119     } catch (std::exception& e) {
40120       {
40121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40122       };
40123     } catch (Dali::DaliException e) {
40124       {
40125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40126       };
40127     } catch (...) {
40128       {
40129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40130       };
40131     }
40132   }
40133
40134   jresult = (void *)result;
40135   return jresult;
40136 }
40137
40138
40139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40140   int jresult ;
40141   int result;
40142
40143   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40144   jresult = (int)result;
40145   return jresult;
40146 }
40147
40148
40149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40150   int jresult ;
40151   int result;
40152
40153   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40154   jresult = (int)result;
40155   return jresult;
40156 }
40157
40158
40159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40160   int jresult ;
40161   int result;
40162
40163   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40164   jresult = (int)result;
40165   return jresult;
40166 }
40167
40168
40169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40170   int jresult ;
40171   int result;
40172
40173   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40174   jresult = (int)result;
40175   return jresult;
40176 }
40177
40178
40179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40180   int jresult ;
40181   int result;
40182
40183   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40184   jresult = (int)result;
40185   return jresult;
40186 }
40187
40188
40189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40190   int jresult ;
40191   int result;
40192
40193   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40194   jresult = (int)result;
40195   return jresult;
40196 }
40197
40198
40199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40200   int jresult ;
40201   int result;
40202
40203   result = (int)Dali::PanGestureDetector::Property::PANNING;
40204   jresult = (int)result;
40205   return jresult;
40206 }
40207
40208
40209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40210   void * jresult ;
40211   Dali::PanGestureDetector::Property *result = 0 ;
40212
40213   {
40214     try {
40215       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40216     } catch (std::out_of_range& e) {
40217       {
40218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40219       };
40220     } catch (std::exception& e) {
40221       {
40222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40223       };
40224     } catch (Dali::DaliException e) {
40225       {
40226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40227       };
40228     } catch (...) {
40229       {
40230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40231       };
40232     }
40233   }
40234
40235   jresult = (void *)result;
40236   return jresult;
40237 }
40238
40239
40240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40241   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40242
40243   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40244   {
40245     try {
40246       delete arg1;
40247     } catch (std::out_of_range& e) {
40248       {
40249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40250       };
40251     } catch (std::exception& e) {
40252       {
40253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40254       };
40255     } catch (Dali::DaliException e) {
40256       {
40257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40258       };
40259     } catch (...) {
40260       {
40261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40262       };
40263     }
40264   }
40265
40266 }
40267
40268
40269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40270   void * jresult ;
40271   Dali::Radian *result = 0 ;
40272
40273   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40274   jresult = (void *)result;
40275   return jresult;
40276 }
40277
40278
40279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40280   void * jresult ;
40281   Dali::Radian *result = 0 ;
40282
40283   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40284   jresult = (void *)result;
40285   return jresult;
40286 }
40287
40288
40289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40290   void * jresult ;
40291   Dali::Radian *result = 0 ;
40292
40293   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40294   jresult = (void *)result;
40295   return jresult;
40296 }
40297
40298
40299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40300   void * jresult ;
40301   Dali::Radian *result = 0 ;
40302
40303   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40304   jresult = (void *)result;
40305   return jresult;
40306 }
40307
40308
40309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40310   void * jresult ;
40311   Dali::Radian *result = 0 ;
40312
40313   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40314   jresult = (void *)result;
40315   return jresult;
40316 }
40317
40318
40319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40320   void * jresult ;
40321   Dali::Radian *result = 0 ;
40322
40323   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40324   jresult = (void *)result;
40325   return jresult;
40326 }
40327
40328
40329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40330   void * jresult ;
40331   Dali::Radian *result = 0 ;
40332
40333   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40334   jresult = (void *)result;
40335   return jresult;
40336 }
40337
40338
40339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40340   void * jresult ;
40341   Dali::PanGestureDetector *result = 0 ;
40342
40343   {
40344     try {
40345       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40346     } catch (std::out_of_range& e) {
40347       {
40348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40349       };
40350     } catch (std::exception& e) {
40351       {
40352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40353       };
40354     } catch (Dali::DaliException e) {
40355       {
40356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40357       };
40358     } catch (...) {
40359       {
40360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40361       };
40362     }
40363   }
40364
40365   jresult = (void *)result;
40366   return jresult;
40367 }
40368
40369
40370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40371   void * jresult ;
40372   Dali::PanGestureDetector result;
40373
40374   {
40375     try {
40376       result = Dali::PanGestureDetector::New();
40377     } catch (std::out_of_range& e) {
40378       {
40379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40380       };
40381     } catch (std::exception& e) {
40382       {
40383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40384       };
40385     } catch (Dali::DaliException e) {
40386       {
40387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40388       };
40389     } catch (...) {
40390       {
40391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40392       };
40393     }
40394   }
40395
40396   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40397   return jresult;
40398 }
40399
40400
40401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40402   void * jresult ;
40403   Dali::BaseHandle arg1 ;
40404   Dali::BaseHandle *argp1 ;
40405   Dali::PanGestureDetector result;
40406
40407   argp1 = (Dali::BaseHandle *)jarg1;
40408   if (!argp1) {
40409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40410     return 0;
40411   }
40412   arg1 = *argp1;
40413   {
40414     try {
40415       result = Dali::PanGestureDetector::DownCast(arg1);
40416     } catch (std::out_of_range& e) {
40417       {
40418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40419       };
40420     } catch (std::exception& e) {
40421       {
40422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40423       };
40424     } catch (Dali::DaliException e) {
40425       {
40426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40427       };
40428     } catch (...) {
40429       {
40430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40431       };
40432     }
40433   }
40434
40435   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40436   return jresult;
40437 }
40438
40439
40440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40441   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40442
40443   arg1 = (Dali::PanGestureDetector *)jarg1;
40444   {
40445     try {
40446       delete arg1;
40447     } catch (std::out_of_range& e) {
40448       {
40449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40450       };
40451     } catch (std::exception& e) {
40452       {
40453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40454       };
40455     } catch (Dali::DaliException e) {
40456       {
40457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40458       };
40459     } catch (...) {
40460       {
40461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40462       };
40463     }
40464   }
40465
40466 }
40467
40468
40469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40470   void * jresult ;
40471   Dali::PanGestureDetector *arg1 = 0 ;
40472   Dali::PanGestureDetector *result = 0 ;
40473
40474   arg1 = (Dali::PanGestureDetector *)jarg1;
40475   if (!arg1) {
40476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40477     return 0;
40478   }
40479   {
40480     try {
40481       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40482     } catch (std::out_of_range& e) {
40483       {
40484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40485       };
40486     } catch (std::exception& e) {
40487       {
40488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40489       };
40490     } catch (Dali::DaliException e) {
40491       {
40492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40493       };
40494     } catch (...) {
40495       {
40496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40497       };
40498     }
40499   }
40500
40501   jresult = (void *)result;
40502   return jresult;
40503 }
40504
40505
40506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40507   void * jresult ;
40508   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40509   Dali::PanGestureDetector *arg2 = 0 ;
40510   Dali::PanGestureDetector *result = 0 ;
40511
40512   arg1 = (Dali::PanGestureDetector *)jarg1;
40513   arg2 = (Dali::PanGestureDetector *)jarg2;
40514   if (!arg2) {
40515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40516     return 0;
40517   }
40518   {
40519     try {
40520       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40521     } catch (std::out_of_range& e) {
40522       {
40523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40524       };
40525     } catch (std::exception& e) {
40526       {
40527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40528       };
40529     } catch (Dali::DaliException e) {
40530       {
40531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40532       };
40533     } catch (...) {
40534       {
40535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40536       };
40537     }
40538   }
40539
40540   jresult = (void *)result;
40541   return jresult;
40542 }
40543
40544
40545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40546   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40547   unsigned int arg2 ;
40548
40549   arg1 = (Dali::PanGestureDetector *)jarg1;
40550   arg2 = (unsigned int)jarg2;
40551   {
40552     try {
40553       (arg1)->SetMinimumTouchesRequired(arg2);
40554     } catch (std::out_of_range& e) {
40555       {
40556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40557       };
40558     } catch (std::exception& e) {
40559       {
40560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40561       };
40562     } catch (Dali::DaliException e) {
40563       {
40564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40565       };
40566     } catch (...) {
40567       {
40568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40569       };
40570     }
40571   }
40572
40573 }
40574
40575
40576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40577   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40578   unsigned int arg2 ;
40579
40580   arg1 = (Dali::PanGestureDetector *)jarg1;
40581   arg2 = (unsigned int)jarg2;
40582   {
40583     try {
40584       (arg1)->SetMaximumTouchesRequired(arg2);
40585     } catch (std::out_of_range& e) {
40586       {
40587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40588       };
40589     } catch (std::exception& e) {
40590       {
40591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40592       };
40593     } catch (Dali::DaliException e) {
40594       {
40595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40596       };
40597     } catch (...) {
40598       {
40599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40600       };
40601     }
40602   }
40603
40604 }
40605
40606
40607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40608   unsigned int jresult ;
40609   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40610   unsigned int result;
40611
40612   arg1 = (Dali::PanGestureDetector *)jarg1;
40613   {
40614     try {
40615       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40616     } catch (std::out_of_range& e) {
40617       {
40618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40619       };
40620     } catch (std::exception& e) {
40621       {
40622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40623       };
40624     } catch (Dali::DaliException e) {
40625       {
40626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40627       };
40628     } catch (...) {
40629       {
40630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40631       };
40632     }
40633   }
40634
40635   jresult = result;
40636   return jresult;
40637 }
40638
40639
40640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40641   unsigned int jresult ;
40642   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40643   unsigned int result;
40644
40645   arg1 = (Dali::PanGestureDetector *)jarg1;
40646   {
40647     try {
40648       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40649     } catch (std::out_of_range& e) {
40650       {
40651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40652       };
40653     } catch (std::exception& e) {
40654       {
40655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40656       };
40657     } catch (Dali::DaliException e) {
40658       {
40659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40660       };
40661     } catch (...) {
40662       {
40663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40664       };
40665     }
40666   }
40667
40668   jresult = result;
40669   return jresult;
40670 }
40671
40672
40673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40674   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40675   Dali::Radian arg2 ;
40676   Dali::Radian arg3 ;
40677   Dali::Radian *argp2 ;
40678   Dali::Radian *argp3 ;
40679
40680   arg1 = (Dali::PanGestureDetector *)jarg1;
40681   argp2 = (Dali::Radian *)jarg2;
40682   if (!argp2) {
40683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40684     return ;
40685   }
40686   arg2 = *argp2;
40687   argp3 = (Dali::Radian *)jarg3;
40688   if (!argp3) {
40689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40690     return ;
40691   }
40692   arg3 = *argp3;
40693   {
40694     try {
40695       (arg1)->AddAngle(arg2,arg3);
40696     } catch (std::out_of_range& e) {
40697       {
40698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40699       };
40700     } catch (std::exception& e) {
40701       {
40702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40703       };
40704     } catch (Dali::DaliException e) {
40705       {
40706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40707       };
40708     } catch (...) {
40709       {
40710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40711       };
40712     }
40713   }
40714
40715 }
40716
40717
40718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40719   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40720   Dali::Radian arg2 ;
40721   Dali::Radian *argp2 ;
40722
40723   arg1 = (Dali::PanGestureDetector *)jarg1;
40724   argp2 = (Dali::Radian *)jarg2;
40725   if (!argp2) {
40726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40727     return ;
40728   }
40729   arg2 = *argp2;
40730   {
40731     try {
40732       (arg1)->AddAngle(arg2);
40733     } catch (std::out_of_range& e) {
40734       {
40735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40736       };
40737     } catch (std::exception& e) {
40738       {
40739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40740       };
40741     } catch (Dali::DaliException e) {
40742       {
40743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40744       };
40745     } catch (...) {
40746       {
40747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40748       };
40749     }
40750   }
40751
40752 }
40753
40754
40755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40756   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40757   Dali::Radian arg2 ;
40758   Dali::Radian arg3 ;
40759   Dali::Radian *argp2 ;
40760   Dali::Radian *argp3 ;
40761
40762   arg1 = (Dali::PanGestureDetector *)jarg1;
40763   argp2 = (Dali::Radian *)jarg2;
40764   if (!argp2) {
40765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40766     return ;
40767   }
40768   arg2 = *argp2;
40769   argp3 = (Dali::Radian *)jarg3;
40770   if (!argp3) {
40771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40772     return ;
40773   }
40774   arg3 = *argp3;
40775   {
40776     try {
40777       (arg1)->AddDirection(arg2,arg3);
40778     } catch (std::out_of_range& e) {
40779       {
40780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40781       };
40782     } catch (std::exception& e) {
40783       {
40784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40785       };
40786     } catch (Dali::DaliException e) {
40787       {
40788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40789       };
40790     } catch (...) {
40791       {
40792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40793       };
40794     }
40795   }
40796
40797 }
40798
40799
40800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40801   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40802   Dali::Radian arg2 ;
40803   Dali::Radian *argp2 ;
40804
40805   arg1 = (Dali::PanGestureDetector *)jarg1;
40806   argp2 = (Dali::Radian *)jarg2;
40807   if (!argp2) {
40808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40809     return ;
40810   }
40811   arg2 = *argp2;
40812   {
40813     try {
40814       (arg1)->AddDirection(arg2);
40815     } catch (std::out_of_range& e) {
40816       {
40817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40818       };
40819     } catch (std::exception& e) {
40820       {
40821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40822       };
40823     } catch (Dali::DaliException e) {
40824       {
40825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40826       };
40827     } catch (...) {
40828       {
40829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40830       };
40831     }
40832   }
40833
40834 }
40835
40836
40837 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40838   unsigned long jresult ;
40839   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40840   size_t result;
40841
40842   arg1 = (Dali::PanGestureDetector *)jarg1;
40843   {
40844     try {
40845       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40846     } catch (std::out_of_range& e) {
40847       {
40848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40849       };
40850     } catch (std::exception& e) {
40851       {
40852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40853       };
40854     } catch (Dali::DaliException e) {
40855       {
40856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40857       };
40858     } catch (...) {
40859       {
40860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40861       };
40862     }
40863   }
40864
40865   jresult = (unsigned long)result;
40866   return jresult;
40867 }
40868
40869
40870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40871   void * jresult ;
40872   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40873   size_t arg2 ;
40874   Dali::PanGestureDetector::AngleThresholdPair result;
40875
40876   arg1 = (Dali::PanGestureDetector *)jarg1;
40877   arg2 = (size_t)jarg2;
40878   {
40879     try {
40880       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40881     } catch (std::out_of_range& e) {
40882       {
40883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40884       };
40885     } catch (std::exception& e) {
40886       {
40887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40888       };
40889     } catch (Dali::DaliException e) {
40890       {
40891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40892       };
40893     } catch (...) {
40894       {
40895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40896       };
40897     }
40898   }
40899
40900   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40901   return jresult;
40902 }
40903
40904
40905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40906   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40907
40908   arg1 = (Dali::PanGestureDetector *)jarg1;
40909   {
40910     try {
40911       (arg1)->ClearAngles();
40912     } catch (std::out_of_range& e) {
40913       {
40914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40915       };
40916     } catch (std::exception& e) {
40917       {
40918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40919       };
40920     } catch (Dali::DaliException e) {
40921       {
40922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40923       };
40924     } catch (...) {
40925       {
40926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40927       };
40928     }
40929   }
40930
40931 }
40932
40933
40934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40935   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40936   Dali::Radian arg2 ;
40937   Dali::Radian *argp2 ;
40938
40939   arg1 = (Dali::PanGestureDetector *)jarg1;
40940   argp2 = (Dali::Radian *)jarg2;
40941   if (!argp2) {
40942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40943     return ;
40944   }
40945   arg2 = *argp2;
40946   {
40947     try {
40948       (arg1)->RemoveAngle(arg2);
40949     } catch (std::out_of_range& e) {
40950       {
40951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40952       };
40953     } catch (std::exception& e) {
40954       {
40955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40956       };
40957     } catch (Dali::DaliException e) {
40958       {
40959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40960       };
40961     } catch (...) {
40962       {
40963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40964       };
40965     }
40966   }
40967
40968 }
40969
40970
40971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40972   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40973   Dali::Radian arg2 ;
40974   Dali::Radian *argp2 ;
40975
40976   arg1 = (Dali::PanGestureDetector *)jarg1;
40977   argp2 = (Dali::Radian *)jarg2;
40978   if (!argp2) {
40979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40980     return ;
40981   }
40982   arg2 = *argp2;
40983   {
40984     try {
40985       (arg1)->RemoveDirection(arg2);
40986     } catch (std::out_of_range& e) {
40987       {
40988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40989       };
40990     } catch (std::exception& e) {
40991       {
40992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40993       };
40994     } catch (Dali::DaliException e) {
40995       {
40996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40997       };
40998     } catch (...) {
40999       {
41000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41001       };
41002     }
41003   }
41004
41005 }
41006
41007
41008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41009   void * jresult ;
41010   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41011   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41012
41013   arg1 = (Dali::PanGestureDetector *)jarg1;
41014   {
41015     try {
41016       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41017     } catch (std::out_of_range& e) {
41018       {
41019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41020       };
41021     } catch (std::exception& e) {
41022       {
41023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41024       };
41025     } catch (Dali::DaliException e) {
41026       {
41027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41028       };
41029     } catch (...) {
41030       {
41031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41032       };
41033     }
41034   }
41035
41036   jresult = (void *)result;
41037   return jresult;
41038 }
41039
41040
41041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41042   Dali::PanGesture *arg1 = 0 ;
41043
41044   arg1 = (Dali::PanGesture *)jarg1;
41045   if (!arg1) {
41046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41047     return ;
41048   }
41049   {
41050     try {
41051       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41052     } catch (std::out_of_range& e) {
41053       {
41054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41055       };
41056     } catch (std::exception& e) {
41057       {
41058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41059       };
41060     } catch (Dali::DaliException e) {
41061       {
41062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41063       };
41064     } catch (...) {
41065       {
41066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41067       };
41068     }
41069   }
41070
41071 }
41072
41073
41074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41075   void * jresult ;
41076   Dali::PanGesture *result = 0 ;
41077
41078   {
41079     try {
41080       result = (Dali::PanGesture *)new Dali::PanGesture();
41081     } catch (std::out_of_range& e) {
41082       {
41083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41084       };
41085     } catch (std::exception& e) {
41086       {
41087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41088       };
41089     } catch (Dali::DaliException e) {
41090       {
41091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41092       };
41093     } catch (...) {
41094       {
41095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41096       };
41097     }
41098   }
41099
41100   jresult = (void *)result;
41101   return jresult;
41102 }
41103
41104
41105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41106   void * jresult ;
41107   Dali::Gesture::State arg1 ;
41108   Dali::PanGesture *result = 0 ;
41109
41110   arg1 = (Dali::Gesture::State)jarg1;
41111   {
41112     try {
41113       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41114     } catch (std::out_of_range& e) {
41115       {
41116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41117       };
41118     } catch (std::exception& e) {
41119       {
41120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41121       };
41122     } catch (Dali::DaliException e) {
41123       {
41124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41125       };
41126     } catch (...) {
41127       {
41128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41129       };
41130     }
41131   }
41132
41133   jresult = (void *)result;
41134   return jresult;
41135 }
41136
41137
41138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41139   void * jresult ;
41140   Dali::PanGesture *arg1 = 0 ;
41141   Dali::PanGesture *result = 0 ;
41142
41143   arg1 = (Dali::PanGesture *)jarg1;
41144   if (!arg1) {
41145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41146     return 0;
41147   }
41148   {
41149     try {
41150       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41151     } catch (std::out_of_range& e) {
41152       {
41153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41154       };
41155     } catch (std::exception& e) {
41156       {
41157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41158       };
41159     } catch (Dali::DaliException e) {
41160       {
41161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41162       };
41163     } catch (...) {
41164       {
41165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41166       };
41167     }
41168   }
41169
41170   jresult = (void *)result;
41171   return jresult;
41172 }
41173
41174
41175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41176   void * jresult ;
41177   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41178   Dali::PanGesture *arg2 = 0 ;
41179   Dali::PanGesture *result = 0 ;
41180
41181   arg1 = (Dali::PanGesture *)jarg1;
41182   arg2 = (Dali::PanGesture *)jarg2;
41183   if (!arg2) {
41184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41185     return 0;
41186   }
41187   {
41188     try {
41189       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41190     } catch (std::out_of_range& e) {
41191       {
41192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41193       };
41194     } catch (std::exception& e) {
41195       {
41196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41197       };
41198     } catch (Dali::DaliException e) {
41199       {
41200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41201       };
41202     } catch (...) {
41203       {
41204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41205       };
41206     }
41207   }
41208
41209   jresult = (void *)result;
41210   return jresult;
41211 }
41212
41213
41214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41215   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41216
41217   arg1 = (Dali::PanGesture *)jarg1;
41218   {
41219     try {
41220       delete arg1;
41221     } catch (std::out_of_range& e) {
41222       {
41223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41224       };
41225     } catch (std::exception& e) {
41226       {
41227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41228       };
41229     } catch (Dali::DaliException e) {
41230       {
41231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41232       };
41233     } catch (...) {
41234       {
41235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41236       };
41237     }
41238   }
41239
41240 }
41241
41242
41243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41244   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41245   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41246
41247   arg1 = (Dali::PanGesture *)jarg1;
41248   arg2 = (Dali::Vector2 *)jarg2;
41249   if (arg1) (arg1)->velocity = *arg2;
41250 }
41251
41252
41253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41254   void * jresult ;
41255   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41256   Dali::Vector2 *result = 0 ;
41257
41258   arg1 = (Dali::PanGesture *)jarg1;
41259   result = (Dali::Vector2 *)& ((arg1)->velocity);
41260   jresult = (void *)result;
41261   return jresult;
41262 }
41263
41264
41265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41266   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41267   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41268
41269   arg1 = (Dali::PanGesture *)jarg1;
41270   arg2 = (Dali::Vector2 *)jarg2;
41271   if (arg1) (arg1)->displacement = *arg2;
41272 }
41273
41274
41275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41276   void * jresult ;
41277   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41278   Dali::Vector2 *result = 0 ;
41279
41280   arg1 = (Dali::PanGesture *)jarg1;
41281   result = (Dali::Vector2 *)& ((arg1)->displacement);
41282   jresult = (void *)result;
41283   return jresult;
41284 }
41285
41286
41287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41288   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41289   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41290
41291   arg1 = (Dali::PanGesture *)jarg1;
41292   arg2 = (Dali::Vector2 *)jarg2;
41293   if (arg1) (arg1)->position = *arg2;
41294 }
41295
41296
41297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41298   void * jresult ;
41299   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41300   Dali::Vector2 *result = 0 ;
41301
41302   arg1 = (Dali::PanGesture *)jarg1;
41303   result = (Dali::Vector2 *)& ((arg1)->position);
41304   jresult = (void *)result;
41305   return jresult;
41306 }
41307
41308
41309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41310   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41311   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41312
41313   arg1 = (Dali::PanGesture *)jarg1;
41314   arg2 = (Dali::Vector2 *)jarg2;
41315   if (arg1) (arg1)->screenVelocity = *arg2;
41316 }
41317
41318
41319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41320   void * jresult ;
41321   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41322   Dali::Vector2 *result = 0 ;
41323
41324   arg1 = (Dali::PanGesture *)jarg1;
41325   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41326   jresult = (void *)result;
41327   return jresult;
41328 }
41329
41330
41331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41332   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41333   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41334
41335   arg1 = (Dali::PanGesture *)jarg1;
41336   arg2 = (Dali::Vector2 *)jarg2;
41337   if (arg1) (arg1)->screenDisplacement = *arg2;
41338 }
41339
41340
41341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41342   void * jresult ;
41343   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41344   Dali::Vector2 *result = 0 ;
41345
41346   arg1 = (Dali::PanGesture *)jarg1;
41347   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41348   jresult = (void *)result;
41349   return jresult;
41350 }
41351
41352
41353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41354   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41355   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41356
41357   arg1 = (Dali::PanGesture *)jarg1;
41358   arg2 = (Dali::Vector2 *)jarg2;
41359   if (arg1) (arg1)->screenPosition = *arg2;
41360 }
41361
41362
41363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41364   void * jresult ;
41365   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41366   Dali::Vector2 *result = 0 ;
41367
41368   arg1 = (Dali::PanGesture *)jarg1;
41369   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41370   jresult = (void *)result;
41371   return jresult;
41372 }
41373
41374
41375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41376   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41377   unsigned int arg2 ;
41378
41379   arg1 = (Dali::PanGesture *)jarg1;
41380   arg2 = (unsigned int)jarg2;
41381   if (arg1) (arg1)->numberOfTouches = arg2;
41382 }
41383
41384
41385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41386   unsigned int jresult ;
41387   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41388   unsigned int result;
41389
41390   arg1 = (Dali::PanGesture *)jarg1;
41391   result = (unsigned int) ((arg1)->numberOfTouches);
41392   jresult = result;
41393   return jresult;
41394 }
41395
41396
41397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41398   float jresult ;
41399   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41400   float result;
41401
41402   arg1 = (Dali::PanGesture *)jarg1;
41403   {
41404     try {
41405       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41406     } catch (std::out_of_range& e) {
41407       {
41408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41409       };
41410     } catch (std::exception& e) {
41411       {
41412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41413       };
41414     } catch (Dali::DaliException e) {
41415       {
41416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41417       };
41418     } catch (...) {
41419       {
41420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41421       };
41422     }
41423   }
41424
41425   jresult = result;
41426   return jresult;
41427 }
41428
41429
41430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41431   float jresult ;
41432   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41433   float result;
41434
41435   arg1 = (Dali::PanGesture *)jarg1;
41436   {
41437     try {
41438       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41439     } catch (std::out_of_range& e) {
41440       {
41441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41442       };
41443     } catch (std::exception& e) {
41444       {
41445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41446       };
41447     } catch (Dali::DaliException e) {
41448       {
41449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41450       };
41451     } catch (...) {
41452       {
41453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41454       };
41455     }
41456   }
41457
41458   jresult = result;
41459   return jresult;
41460 }
41461
41462
41463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41464   float jresult ;
41465   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41466   float result;
41467
41468   arg1 = (Dali::PanGesture *)jarg1;
41469   {
41470     try {
41471       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41472     } catch (std::out_of_range& e) {
41473       {
41474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41475       };
41476     } catch (std::exception& e) {
41477       {
41478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41479       };
41480     } catch (Dali::DaliException e) {
41481       {
41482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41483       };
41484     } catch (...) {
41485       {
41486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41487       };
41488     }
41489   }
41490
41491   jresult = result;
41492   return jresult;
41493 }
41494
41495
41496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41497   float jresult ;
41498   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41499   float result;
41500
41501   arg1 = (Dali::PanGesture *)jarg1;
41502   {
41503     try {
41504       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41505     } catch (std::out_of_range& e) {
41506       {
41507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41508       };
41509     } catch (std::exception& e) {
41510       {
41511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41512       };
41513     } catch (Dali::DaliException e) {
41514       {
41515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41516       };
41517     } catch (...) {
41518       {
41519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41520       };
41521     }
41522   }
41523
41524   jresult = result;
41525   return jresult;
41526 }
41527
41528
41529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41530   void * jresult ;
41531   Dali::PinchGestureDetector *result = 0 ;
41532
41533   {
41534     try {
41535       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41536     } catch (std::out_of_range& e) {
41537       {
41538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41539       };
41540     } catch (std::exception& e) {
41541       {
41542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41543       };
41544     } catch (Dali::DaliException e) {
41545       {
41546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41547       };
41548     } catch (...) {
41549       {
41550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41551       };
41552     }
41553   }
41554
41555   jresult = (void *)result;
41556   return jresult;
41557 }
41558
41559
41560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41561   void * jresult ;
41562   Dali::PinchGestureDetector result;
41563
41564   {
41565     try {
41566       result = Dali::PinchGestureDetector::New();
41567     } catch (std::out_of_range& e) {
41568       {
41569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41570       };
41571     } catch (std::exception& e) {
41572       {
41573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41574       };
41575     } catch (Dali::DaliException e) {
41576       {
41577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41578       };
41579     } catch (...) {
41580       {
41581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41582       };
41583     }
41584   }
41585
41586   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41587   return jresult;
41588 }
41589
41590
41591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41592   void * jresult ;
41593   Dali::BaseHandle arg1 ;
41594   Dali::BaseHandle *argp1 ;
41595   Dali::PinchGestureDetector result;
41596
41597   argp1 = (Dali::BaseHandle *)jarg1;
41598   if (!argp1) {
41599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41600     return 0;
41601   }
41602   arg1 = *argp1;
41603   {
41604     try {
41605       result = Dali::PinchGestureDetector::DownCast(arg1);
41606     } catch (std::out_of_range& e) {
41607       {
41608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41609       };
41610     } catch (std::exception& e) {
41611       {
41612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41613       };
41614     } catch (Dali::DaliException e) {
41615       {
41616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41617       };
41618     } catch (...) {
41619       {
41620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41621       };
41622     }
41623   }
41624
41625   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41626   return jresult;
41627 }
41628
41629
41630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41631   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41632
41633   arg1 = (Dali::PinchGestureDetector *)jarg1;
41634   {
41635     try {
41636       delete arg1;
41637     } catch (std::out_of_range& e) {
41638       {
41639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41640       };
41641     } catch (std::exception& e) {
41642       {
41643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41644       };
41645     } catch (Dali::DaliException e) {
41646       {
41647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41648       };
41649     } catch (...) {
41650       {
41651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41652       };
41653     }
41654   }
41655
41656 }
41657
41658
41659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41660   void * jresult ;
41661   Dali::PinchGestureDetector *arg1 = 0 ;
41662   Dali::PinchGestureDetector *result = 0 ;
41663
41664   arg1 = (Dali::PinchGestureDetector *)jarg1;
41665   if (!arg1) {
41666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41667     return 0;
41668   }
41669   {
41670     try {
41671       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41672     } catch (std::out_of_range& e) {
41673       {
41674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41675       };
41676     } catch (std::exception& e) {
41677       {
41678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41679       };
41680     } catch (Dali::DaliException e) {
41681       {
41682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41683       };
41684     } catch (...) {
41685       {
41686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41687       };
41688     }
41689   }
41690
41691   jresult = (void *)result;
41692   return jresult;
41693 }
41694
41695
41696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41697   void * jresult ;
41698   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41699   Dali::PinchGestureDetector *arg2 = 0 ;
41700   Dali::PinchGestureDetector *result = 0 ;
41701
41702   arg1 = (Dali::PinchGestureDetector *)jarg1;
41703   arg2 = (Dali::PinchGestureDetector *)jarg2;
41704   if (!arg2) {
41705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41706     return 0;
41707   }
41708   {
41709     try {
41710       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41711     } catch (std::out_of_range& e) {
41712       {
41713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41714       };
41715     } catch (std::exception& e) {
41716       {
41717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41718       };
41719     } catch (Dali::DaliException e) {
41720       {
41721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41722       };
41723     } catch (...) {
41724       {
41725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41726       };
41727     }
41728   }
41729
41730   jresult = (void *)result;
41731   return jresult;
41732 }
41733
41734
41735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41736   void * jresult ;
41737   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41738   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41739
41740   arg1 = (Dali::PinchGestureDetector *)jarg1;
41741   {
41742     try {
41743       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41744     } catch (std::out_of_range& e) {
41745       {
41746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41747       };
41748     } catch (std::exception& e) {
41749       {
41750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41751       };
41752     } catch (Dali::DaliException e) {
41753       {
41754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41755       };
41756     } catch (...) {
41757       {
41758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41759       };
41760     }
41761   }
41762
41763   jresult = (void *)result;
41764   return jresult;
41765 }
41766
41767
41768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41769   void * jresult ;
41770   Dali::Gesture::State arg1 ;
41771   Dali::PinchGesture *result = 0 ;
41772
41773   arg1 = (Dali::Gesture::State)jarg1;
41774   {
41775     try {
41776       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41777     } catch (std::out_of_range& e) {
41778       {
41779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41780       };
41781     } catch (std::exception& e) {
41782       {
41783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41784       };
41785     } catch (Dali::DaliException e) {
41786       {
41787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41788       };
41789     } catch (...) {
41790       {
41791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41792       };
41793     }
41794   }
41795
41796   jresult = (void *)result;
41797   return jresult;
41798 }
41799
41800
41801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41802   void * jresult ;
41803   Dali::PinchGesture *arg1 = 0 ;
41804   Dali::PinchGesture *result = 0 ;
41805
41806   arg1 = (Dali::PinchGesture *)jarg1;
41807   if (!arg1) {
41808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41809     return 0;
41810   }
41811   {
41812     try {
41813       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41814     } catch (std::out_of_range& e) {
41815       {
41816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41817       };
41818     } catch (std::exception& e) {
41819       {
41820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41821       };
41822     } catch (Dali::DaliException e) {
41823       {
41824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41825       };
41826     } catch (...) {
41827       {
41828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41829       };
41830     }
41831   }
41832
41833   jresult = (void *)result;
41834   return jresult;
41835 }
41836
41837
41838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41839   void * jresult ;
41840   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41841   Dali::PinchGesture *arg2 = 0 ;
41842   Dali::PinchGesture *result = 0 ;
41843
41844   arg1 = (Dali::PinchGesture *)jarg1;
41845   arg2 = (Dali::PinchGesture *)jarg2;
41846   if (!arg2) {
41847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41848     return 0;
41849   }
41850   {
41851     try {
41852       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41853     } catch (std::out_of_range& e) {
41854       {
41855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41856       };
41857     } catch (std::exception& e) {
41858       {
41859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41860       };
41861     } catch (Dali::DaliException e) {
41862       {
41863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41864       };
41865     } catch (...) {
41866       {
41867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41868       };
41869     }
41870   }
41871
41872   jresult = (void *)result;
41873   return jresult;
41874 }
41875
41876
41877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41878   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41879
41880   arg1 = (Dali::PinchGesture *)jarg1;
41881   {
41882     try {
41883       delete arg1;
41884     } catch (std::out_of_range& e) {
41885       {
41886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41887       };
41888     } catch (std::exception& e) {
41889       {
41890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41891       };
41892     } catch (Dali::DaliException e) {
41893       {
41894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41895       };
41896     } catch (...) {
41897       {
41898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41899       };
41900     }
41901   }
41902
41903 }
41904
41905
41906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41907   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41908   float arg2 ;
41909
41910   arg1 = (Dali::PinchGesture *)jarg1;
41911   arg2 = (float)jarg2;
41912   if (arg1) (arg1)->scale = arg2;
41913 }
41914
41915
41916 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41917   float jresult ;
41918   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41919   float result;
41920
41921   arg1 = (Dali::PinchGesture *)jarg1;
41922   result = (float) ((arg1)->scale);
41923   jresult = result;
41924   return jresult;
41925 }
41926
41927
41928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41929   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41930   float arg2 ;
41931
41932   arg1 = (Dali::PinchGesture *)jarg1;
41933   arg2 = (float)jarg2;
41934   if (arg1) (arg1)->speed = arg2;
41935 }
41936
41937
41938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41939   float jresult ;
41940   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41941   float result;
41942
41943   arg1 = (Dali::PinchGesture *)jarg1;
41944   result = (float) ((arg1)->speed);
41945   jresult = result;
41946   return jresult;
41947 }
41948
41949
41950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41951   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41952   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41953
41954   arg1 = (Dali::PinchGesture *)jarg1;
41955   arg2 = (Dali::Vector2 *)jarg2;
41956   if (arg1) (arg1)->screenCenterPoint = *arg2;
41957 }
41958
41959
41960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41961   void * jresult ;
41962   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41963   Dali::Vector2 *result = 0 ;
41964
41965   arg1 = (Dali::PinchGesture *)jarg1;
41966   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41967   jresult = (void *)result;
41968   return jresult;
41969 }
41970
41971
41972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41973   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41974   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41975
41976   arg1 = (Dali::PinchGesture *)jarg1;
41977   arg2 = (Dali::Vector2 *)jarg2;
41978   if (arg1) (arg1)->localCenterPoint = *arg2;
41979 }
41980
41981
41982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41983   void * jresult ;
41984   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41985   Dali::Vector2 *result = 0 ;
41986
41987   arg1 = (Dali::PinchGesture *)jarg1;
41988   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41989   jresult = (void *)result;
41990   return jresult;
41991 }
41992
41993
41994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41995   void * jresult ;
41996   Dali::TapGestureDetector *result = 0 ;
41997
41998   {
41999     try {
42000       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42001     } catch (std::out_of_range& e) {
42002       {
42003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42004       };
42005     } catch (std::exception& e) {
42006       {
42007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42008       };
42009     } catch (Dali::DaliException e) {
42010       {
42011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42012       };
42013     } catch (...) {
42014       {
42015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42016       };
42017     }
42018   }
42019
42020   jresult = (void *)result;
42021   return jresult;
42022 }
42023
42024
42025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42026   void * jresult ;
42027   Dali::TapGestureDetector result;
42028
42029   {
42030     try {
42031       result = Dali::TapGestureDetector::New();
42032     } catch (std::out_of_range& e) {
42033       {
42034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42035       };
42036     } catch (std::exception& e) {
42037       {
42038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42039       };
42040     } catch (Dali::DaliException e) {
42041       {
42042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42043       };
42044     } catch (...) {
42045       {
42046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42047       };
42048     }
42049   }
42050
42051   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42052   return jresult;
42053 }
42054
42055
42056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42057   void * jresult ;
42058   unsigned int arg1 ;
42059   Dali::TapGestureDetector result;
42060
42061   arg1 = (unsigned int)jarg1;
42062   {
42063     try {
42064       result = Dali::TapGestureDetector::New(arg1);
42065     } catch (std::out_of_range& e) {
42066       {
42067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42068       };
42069     } catch (std::exception& e) {
42070       {
42071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42072       };
42073     } catch (Dali::DaliException e) {
42074       {
42075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42076       };
42077     } catch (...) {
42078       {
42079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42080       };
42081     }
42082   }
42083
42084   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42085   return jresult;
42086 }
42087
42088
42089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42090   void * jresult ;
42091   Dali::BaseHandle arg1 ;
42092   Dali::BaseHandle *argp1 ;
42093   Dali::TapGestureDetector result;
42094
42095   argp1 = (Dali::BaseHandle *)jarg1;
42096   if (!argp1) {
42097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42098     return 0;
42099   }
42100   arg1 = *argp1;
42101   {
42102     try {
42103       result = Dali::TapGestureDetector::DownCast(arg1);
42104     } catch (std::out_of_range& e) {
42105       {
42106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42107       };
42108     } catch (std::exception& e) {
42109       {
42110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42111       };
42112     } catch (Dali::DaliException e) {
42113       {
42114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42115       };
42116     } catch (...) {
42117       {
42118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42119       };
42120     }
42121   }
42122
42123   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42124   return jresult;
42125 }
42126
42127
42128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42129   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42130
42131   arg1 = (Dali::TapGestureDetector *)jarg1;
42132   {
42133     try {
42134       delete arg1;
42135     } catch (std::out_of_range& e) {
42136       {
42137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42138       };
42139     } catch (std::exception& e) {
42140       {
42141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42142       };
42143     } catch (Dali::DaliException e) {
42144       {
42145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42146       };
42147     } catch (...) {
42148       {
42149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42150       };
42151     }
42152   }
42153
42154 }
42155
42156
42157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42158   void * jresult ;
42159   Dali::TapGestureDetector *arg1 = 0 ;
42160   Dali::TapGestureDetector *result = 0 ;
42161
42162   arg1 = (Dali::TapGestureDetector *)jarg1;
42163   if (!arg1) {
42164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42165     return 0;
42166   }
42167   {
42168     try {
42169       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42170     } catch (std::out_of_range& e) {
42171       {
42172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42173       };
42174     } catch (std::exception& e) {
42175       {
42176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42177       };
42178     } catch (Dali::DaliException e) {
42179       {
42180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42181       };
42182     } catch (...) {
42183       {
42184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42185       };
42186     }
42187   }
42188
42189   jresult = (void *)result;
42190   return jresult;
42191 }
42192
42193
42194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42195   void * jresult ;
42196   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42197   Dali::TapGestureDetector *arg2 = 0 ;
42198   Dali::TapGestureDetector *result = 0 ;
42199
42200   arg1 = (Dali::TapGestureDetector *)jarg1;
42201   arg2 = (Dali::TapGestureDetector *)jarg2;
42202   if (!arg2) {
42203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42204     return 0;
42205   }
42206   {
42207     try {
42208       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42209     } catch (std::out_of_range& e) {
42210       {
42211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42212       };
42213     } catch (std::exception& e) {
42214       {
42215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42216       };
42217     } catch (Dali::DaliException e) {
42218       {
42219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42220       };
42221     } catch (...) {
42222       {
42223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42224       };
42225     }
42226   }
42227
42228   jresult = (void *)result;
42229   return jresult;
42230 }
42231
42232
42233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42234   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42235   unsigned int arg2 ;
42236
42237   arg1 = (Dali::TapGestureDetector *)jarg1;
42238   arg2 = (unsigned int)jarg2;
42239   {
42240     try {
42241       (arg1)->SetMinimumTapsRequired(arg2);
42242     } catch (std::out_of_range& e) {
42243       {
42244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42245       };
42246     } catch (std::exception& e) {
42247       {
42248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42249       };
42250     } catch (Dali::DaliException e) {
42251       {
42252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42253       };
42254     } catch (...) {
42255       {
42256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42257       };
42258     }
42259   }
42260
42261 }
42262
42263
42264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42265   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42266   unsigned int arg2 ;
42267
42268   arg1 = (Dali::TapGestureDetector *)jarg1;
42269   arg2 = (unsigned int)jarg2;
42270   {
42271     try {
42272       (arg1)->SetMaximumTapsRequired(arg2);
42273     } catch (std::out_of_range& e) {
42274       {
42275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42276       };
42277     } catch (std::exception& e) {
42278       {
42279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42280       };
42281     } catch (Dali::DaliException e) {
42282       {
42283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42284       };
42285     } catch (...) {
42286       {
42287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42288       };
42289     }
42290   }
42291
42292 }
42293
42294
42295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42296   unsigned int jresult ;
42297   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42298   unsigned int result;
42299
42300   arg1 = (Dali::TapGestureDetector *)jarg1;
42301   {
42302     try {
42303       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42304     } catch (std::out_of_range& e) {
42305       {
42306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42307       };
42308     } catch (std::exception& e) {
42309       {
42310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42311       };
42312     } catch (Dali::DaliException e) {
42313       {
42314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42315       };
42316     } catch (...) {
42317       {
42318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42319       };
42320     }
42321   }
42322
42323   jresult = result;
42324   return jresult;
42325 }
42326
42327
42328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42329   unsigned int jresult ;
42330   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42331   unsigned int result;
42332
42333   arg1 = (Dali::TapGestureDetector *)jarg1;
42334   {
42335     try {
42336       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42337     } catch (std::out_of_range& e) {
42338       {
42339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42340       };
42341     } catch (std::exception& e) {
42342       {
42343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42344       };
42345     } catch (Dali::DaliException e) {
42346       {
42347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42348       };
42349     } catch (...) {
42350       {
42351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42352       };
42353     }
42354   }
42355
42356   jresult = result;
42357   return jresult;
42358 }
42359
42360
42361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42362   void * jresult ;
42363   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42364   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42365
42366   arg1 = (Dali::TapGestureDetector *)jarg1;
42367   {
42368     try {
42369       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42370     } catch (std::out_of_range& e) {
42371       {
42372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42373       };
42374     } catch (std::exception& e) {
42375       {
42376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42377       };
42378     } catch (Dali::DaliException e) {
42379       {
42380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42381       };
42382     } catch (...) {
42383       {
42384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42385       };
42386     }
42387   }
42388
42389   jresult = (void *)result;
42390   return jresult;
42391 }
42392
42393
42394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42395   void * jresult ;
42396   Dali::TapGesture *result = 0 ;
42397
42398   {
42399     try {
42400       result = (Dali::TapGesture *)new Dali::TapGesture();
42401     } catch (std::out_of_range& e) {
42402       {
42403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42404       };
42405     } catch (std::exception& e) {
42406       {
42407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42408       };
42409     } catch (Dali::DaliException e) {
42410       {
42411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42412       };
42413     } catch (...) {
42414       {
42415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42416       };
42417     }
42418   }
42419
42420   jresult = (void *)result;
42421   return jresult;
42422 }
42423
42424
42425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42426   void * jresult ;
42427   Dali::TapGesture *arg1 = 0 ;
42428   Dali::TapGesture *result = 0 ;
42429
42430   arg1 = (Dali::TapGesture *)jarg1;
42431   if (!arg1) {
42432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42433     return 0;
42434   }
42435   {
42436     try {
42437       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42438     } catch (std::out_of_range& e) {
42439       {
42440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42441       };
42442     } catch (std::exception& e) {
42443       {
42444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42445       };
42446     } catch (Dali::DaliException e) {
42447       {
42448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42449       };
42450     } catch (...) {
42451       {
42452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42453       };
42454     }
42455   }
42456
42457   jresult = (void *)result;
42458   return jresult;
42459 }
42460
42461
42462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42463   void * jresult ;
42464   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42465   Dali::TapGesture *arg2 = 0 ;
42466   Dali::TapGesture *result = 0 ;
42467
42468   arg1 = (Dali::TapGesture *)jarg1;
42469   arg2 = (Dali::TapGesture *)jarg2;
42470   if (!arg2) {
42471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42472     return 0;
42473   }
42474   {
42475     try {
42476       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42477     } catch (std::out_of_range& e) {
42478       {
42479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42480       };
42481     } catch (std::exception& e) {
42482       {
42483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42484       };
42485     } catch (Dali::DaliException e) {
42486       {
42487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42488       };
42489     } catch (...) {
42490       {
42491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42492       };
42493     }
42494   }
42495
42496   jresult = (void *)result;
42497   return jresult;
42498 }
42499
42500
42501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42502   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42503
42504   arg1 = (Dali::TapGesture *)jarg1;
42505   {
42506     try {
42507       delete arg1;
42508     } catch (std::out_of_range& e) {
42509       {
42510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42511       };
42512     } catch (std::exception& e) {
42513       {
42514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42515       };
42516     } catch (Dali::DaliException e) {
42517       {
42518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42519       };
42520     } catch (...) {
42521       {
42522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42523       };
42524     }
42525   }
42526
42527 }
42528
42529
42530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42531   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42532   unsigned int arg2 ;
42533
42534   arg1 = (Dali::TapGesture *)jarg1;
42535   arg2 = (unsigned int)jarg2;
42536   if (arg1) (arg1)->numberOfTaps = arg2;
42537 }
42538
42539
42540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42541   unsigned int jresult ;
42542   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42543   unsigned int result;
42544
42545   arg1 = (Dali::TapGesture *)jarg1;
42546   result = (unsigned int) ((arg1)->numberOfTaps);
42547   jresult = result;
42548   return jresult;
42549 }
42550
42551
42552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42553   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42554   unsigned int arg2 ;
42555
42556   arg1 = (Dali::TapGesture *)jarg1;
42557   arg2 = (unsigned int)jarg2;
42558   if (arg1) (arg1)->numberOfTouches = arg2;
42559 }
42560
42561
42562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42563   unsigned int jresult ;
42564   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42565   unsigned int result;
42566
42567   arg1 = (Dali::TapGesture *)jarg1;
42568   result = (unsigned int) ((arg1)->numberOfTouches);
42569   jresult = result;
42570   return jresult;
42571 }
42572
42573
42574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42575   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42576   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42577
42578   arg1 = (Dali::TapGesture *)jarg1;
42579   arg2 = (Dali::Vector2 *)jarg2;
42580   if (arg1) (arg1)->screenPoint = *arg2;
42581 }
42582
42583
42584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42585   void * jresult ;
42586   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42587   Dali::Vector2 *result = 0 ;
42588
42589   arg1 = (Dali::TapGesture *)jarg1;
42590   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42591   jresult = (void *)result;
42592   return jresult;
42593 }
42594
42595
42596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42597   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42598   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42599
42600   arg1 = (Dali::TapGesture *)jarg1;
42601   arg2 = (Dali::Vector2 *)jarg2;
42602   if (arg1) (arg1)->localPoint = *arg2;
42603 }
42604
42605
42606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42607   void * jresult ;
42608   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42609   Dali::Vector2 *result = 0 ;
42610
42611   arg1 = (Dali::TapGesture *)jarg1;
42612   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42613   jresult = (void *)result;
42614   return jresult;
42615 }
42616
42617
42618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42619   void * jresult ;
42620   Dali::AlphaFunction *result = 0 ;
42621
42622   {
42623     try {
42624       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42625     } catch (std::out_of_range& e) {
42626       {
42627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42628       };
42629     } catch (std::exception& e) {
42630       {
42631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42632       };
42633     } catch (Dali::DaliException e) {
42634       {
42635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42636       };
42637     } catch (...) {
42638       {
42639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42640       };
42641     }
42642   }
42643
42644   jresult = (void *)result;
42645   return jresult;
42646 }
42647
42648
42649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42650   void * jresult ;
42651   Dali::AlphaFunction::BuiltinFunction arg1 ;
42652   Dali::AlphaFunction *result = 0 ;
42653
42654   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42655   {
42656     try {
42657       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42658     } catch (std::out_of_range& e) {
42659       {
42660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42661       };
42662     } catch (std::exception& e) {
42663       {
42664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42665       };
42666     } catch (Dali::DaliException e) {
42667       {
42668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42669       };
42670     } catch (...) {
42671       {
42672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42673       };
42674     }
42675   }
42676
42677   jresult = (void *)result;
42678   return jresult;
42679 }
42680
42681
42682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42683   void * jresult ;
42684   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42685   Dali::AlphaFunction *result = 0 ;
42686
42687   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42688   {
42689     try {
42690       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42691     } catch (std::out_of_range& e) {
42692       {
42693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42694       };
42695     } catch (std::exception& e) {
42696       {
42697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42698       };
42699     } catch (Dali::DaliException e) {
42700       {
42701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42702       };
42703     } catch (...) {
42704       {
42705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42706       };
42707     }
42708   }
42709
42710   jresult = (void *)result;
42711   return jresult;
42712 }
42713
42714
42715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42716   void * jresult ;
42717   Dali::Vector2 *arg1 = 0 ;
42718   Dali::Vector2 *arg2 = 0 ;
42719   Dali::AlphaFunction *result = 0 ;
42720
42721   arg1 = (Dali::Vector2 *)jarg1;
42722   if (!arg1) {
42723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42724     return 0;
42725   }
42726   arg2 = (Dali::Vector2 *)jarg2;
42727   if (!arg2) {
42728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42729     return 0;
42730   }
42731   {
42732     try {
42733       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42734     } catch (std::out_of_range& e) {
42735       {
42736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42737       };
42738     } catch (std::exception& e) {
42739       {
42740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42741       };
42742     } catch (Dali::DaliException e) {
42743       {
42744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42745       };
42746     } catch (...) {
42747       {
42748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42749       };
42750     }
42751   }
42752
42753   jresult = (void *)result;
42754   return jresult;
42755 }
42756
42757
42758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42759   void * jresult ;
42760   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42761   Dali::Vector4 result;
42762
42763   arg1 = (Dali::AlphaFunction *)jarg1;
42764   {
42765     try {
42766       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42767     } catch (std::out_of_range& e) {
42768       {
42769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42770       };
42771     } catch (std::exception& e) {
42772       {
42773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42774       };
42775     } catch (Dali::DaliException e) {
42776       {
42777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42778       };
42779     } catch (...) {
42780       {
42781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42782       };
42783     }
42784   }
42785
42786   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42787   return jresult;
42788 }
42789
42790
42791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42792   void * jresult ;
42793   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42794   Dali::AlphaFunctionPrototype result;
42795
42796   arg1 = (Dali::AlphaFunction *)jarg1;
42797   {
42798     try {
42799       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42800     } catch (std::out_of_range& e) {
42801       {
42802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42803       };
42804     } catch (std::exception& e) {
42805       {
42806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42807       };
42808     } catch (Dali::DaliException e) {
42809       {
42810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42811       };
42812     } catch (...) {
42813       {
42814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42815       };
42816     }
42817   }
42818
42819   jresult = (void *)result;
42820   return jresult;
42821 }
42822
42823
42824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42825   int jresult ;
42826   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42827   Dali::AlphaFunction::BuiltinFunction result;
42828
42829   arg1 = (Dali::AlphaFunction *)jarg1;
42830   {
42831     try {
42832       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42833     } catch (std::out_of_range& e) {
42834       {
42835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42836       };
42837     } catch (std::exception& e) {
42838       {
42839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42840       };
42841     } catch (Dali::DaliException e) {
42842       {
42843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42844       };
42845     } catch (...) {
42846       {
42847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42848       };
42849     }
42850   }
42851
42852   jresult = (int)result;
42853   return jresult;
42854 }
42855
42856
42857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42858   int jresult ;
42859   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42860   Dali::AlphaFunction::Mode result;
42861
42862   arg1 = (Dali::AlphaFunction *)jarg1;
42863   {
42864     try {
42865       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42866     } catch (std::out_of_range& e) {
42867       {
42868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42869       };
42870     } catch (std::exception& e) {
42871       {
42872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42873       };
42874     } catch (Dali::DaliException e) {
42875       {
42876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42877       };
42878     } catch (...) {
42879       {
42880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42881       };
42882     }
42883   }
42884
42885   jresult = (int)result;
42886   return jresult;
42887 }
42888
42889
42890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42891   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42892
42893   arg1 = (Dali::AlphaFunction *)jarg1;
42894   {
42895     try {
42896       delete arg1;
42897     } catch (std::out_of_range& e) {
42898       {
42899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42900       };
42901     } catch (std::exception& e) {
42902       {
42903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42904       };
42905     } catch (Dali::DaliException e) {
42906       {
42907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42908       };
42909     } catch (...) {
42910       {
42911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42912       };
42913     }
42914   }
42915
42916 }
42917
42918
42919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42920   void * jresult ;
42921   Dali::KeyFrames result;
42922
42923   {
42924     try {
42925       result = Dali::KeyFrames::New();
42926     } catch (std::out_of_range& e) {
42927       {
42928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42929       };
42930     } catch (std::exception& e) {
42931       {
42932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42933       };
42934     } catch (Dali::DaliException e) {
42935       {
42936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42937       };
42938     } catch (...) {
42939       {
42940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42941       };
42942     }
42943   }
42944
42945   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42946   return jresult;
42947 }
42948
42949
42950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42951   void * jresult ;
42952   Dali::BaseHandle arg1 ;
42953   Dali::BaseHandle *argp1 ;
42954   Dali::KeyFrames result;
42955
42956   argp1 = (Dali::BaseHandle *)jarg1;
42957   if (!argp1) {
42958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42959     return 0;
42960   }
42961   arg1 = *argp1;
42962   {
42963     try {
42964       result = Dali::KeyFrames::DownCast(arg1);
42965     } catch (std::out_of_range& e) {
42966       {
42967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42968       };
42969     } catch (std::exception& e) {
42970       {
42971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42972       };
42973     } catch (Dali::DaliException e) {
42974       {
42975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42976       };
42977     } catch (...) {
42978       {
42979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42980       };
42981     }
42982   }
42983
42984   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42985   return jresult;
42986 }
42987
42988
42989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42990   void * jresult ;
42991   Dali::KeyFrames *result = 0 ;
42992
42993   {
42994     try {
42995       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42996     } catch (std::out_of_range& e) {
42997       {
42998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42999       };
43000     } catch (std::exception& e) {
43001       {
43002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43003       };
43004     } catch (Dali::DaliException e) {
43005       {
43006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43007       };
43008     } catch (...) {
43009       {
43010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43011       };
43012     }
43013   }
43014
43015   jresult = (void *)result;
43016   return jresult;
43017 }
43018
43019
43020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43021   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43022
43023   arg1 = (Dali::KeyFrames *)jarg1;
43024   {
43025     try {
43026       delete arg1;
43027     } catch (std::out_of_range& e) {
43028       {
43029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43030       };
43031     } catch (std::exception& e) {
43032       {
43033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43034       };
43035     } catch (Dali::DaliException e) {
43036       {
43037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43038       };
43039     } catch (...) {
43040       {
43041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43042       };
43043     }
43044   }
43045
43046 }
43047
43048
43049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43050   void * jresult ;
43051   Dali::KeyFrames *arg1 = 0 ;
43052   Dali::KeyFrames *result = 0 ;
43053
43054   arg1 = (Dali::KeyFrames *)jarg1;
43055   if (!arg1) {
43056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43057     return 0;
43058   }
43059   {
43060     try {
43061       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43062     } catch (std::out_of_range& e) {
43063       {
43064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43065       };
43066     } catch (std::exception& e) {
43067       {
43068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43069       };
43070     } catch (Dali::DaliException e) {
43071       {
43072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43073       };
43074     } catch (...) {
43075       {
43076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43077       };
43078     }
43079   }
43080
43081   jresult = (void *)result;
43082   return jresult;
43083 }
43084
43085
43086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43087   void * jresult ;
43088   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43089   Dali::KeyFrames *arg2 = 0 ;
43090   Dali::KeyFrames *result = 0 ;
43091
43092   arg1 = (Dali::KeyFrames *)jarg1;
43093   arg2 = (Dali::KeyFrames *)jarg2;
43094   if (!arg2) {
43095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43096     return 0;
43097   }
43098   {
43099     try {
43100       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43101     } catch (std::out_of_range& e) {
43102       {
43103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43104       };
43105     } catch (std::exception& e) {
43106       {
43107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43108       };
43109     } catch (Dali::DaliException e) {
43110       {
43111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43112       };
43113     } catch (...) {
43114       {
43115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43116       };
43117     }
43118   }
43119
43120   jresult = (void *)result;
43121   return jresult;
43122 }
43123
43124
43125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43126   int jresult ;
43127   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43128   Dali::Property::Type result;
43129
43130   arg1 = (Dali::KeyFrames *)jarg1;
43131   {
43132     try {
43133       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43134     } catch (std::out_of_range& e) {
43135       {
43136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43137       };
43138     } catch (std::exception& e) {
43139       {
43140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43141       };
43142     } catch (Dali::DaliException e) {
43143       {
43144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43145       };
43146     } catch (...) {
43147       {
43148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43149       };
43150     }
43151   }
43152
43153   jresult = (int)result;
43154   return jresult;
43155 }
43156
43157
43158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43159   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43160   float arg2 ;
43161   Dali::Property::Value arg3 ;
43162   Dali::Property::Value *argp3 ;
43163
43164   arg1 = (Dali::KeyFrames *)jarg1;
43165   arg2 = (float)jarg2;
43166   argp3 = (Dali::Property::Value *)jarg3;
43167   if (!argp3) {
43168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43169     return ;
43170   }
43171   arg3 = *argp3;
43172   {
43173     try {
43174       (arg1)->Add(arg2,arg3);
43175     } catch (std::out_of_range& e) {
43176       {
43177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43178       };
43179     } catch (std::exception& e) {
43180       {
43181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43182       };
43183     } catch (Dali::DaliException e) {
43184       {
43185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43186       };
43187     } catch (...) {
43188       {
43189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43190       };
43191     }
43192   }
43193
43194 }
43195
43196
43197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43198   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43199   float arg2 ;
43200   Dali::Property::Value arg3 ;
43201   Dali::AlphaFunction arg4 ;
43202   Dali::Property::Value *argp3 ;
43203   Dali::AlphaFunction *argp4 ;
43204
43205   arg1 = (Dali::KeyFrames *)jarg1;
43206   arg2 = (float)jarg2;
43207   argp3 = (Dali::Property::Value *)jarg3;
43208   if (!argp3) {
43209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43210     return ;
43211   }
43212   arg3 = *argp3;
43213   argp4 = (Dali::AlphaFunction *)jarg4;
43214   if (!argp4) {
43215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43216     return ;
43217   }
43218   arg4 = *argp4;
43219   {
43220     try {
43221       (arg1)->Add(arg2,arg3,arg4);
43222     } catch (std::out_of_range& e) {
43223       {
43224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43225       };
43226     } catch (std::exception& e) {
43227       {
43228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43229       };
43230     } catch (Dali::DaliException e) {
43231       {
43232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43233       };
43234     } catch (...) {
43235       {
43236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43237       };
43238     }
43239   }
43240
43241 }
43242
43243
43244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43245   int jresult ;
43246   int result;
43247
43248   result = (int)Dali::Path::Property::POINTS;
43249   jresult = (int)result;
43250   return jresult;
43251 }
43252
43253
43254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43255   int jresult ;
43256   int result;
43257
43258   result = (int)Dali::Path::Property::CONTROL_POINTS;
43259   jresult = (int)result;
43260   return jresult;
43261 }
43262
43263
43264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43265   void * jresult ;
43266   Dali::Path::Property *result = 0 ;
43267
43268   {
43269     try {
43270       result = (Dali::Path::Property *)new Dali::Path::Property();
43271     } catch (std::out_of_range& e) {
43272       {
43273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43274       };
43275     } catch (std::exception& e) {
43276       {
43277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43278       };
43279     } catch (Dali::DaliException e) {
43280       {
43281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43282       };
43283     } catch (...) {
43284       {
43285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43286       };
43287     }
43288   }
43289
43290   jresult = (void *)result;
43291   return jresult;
43292 }
43293
43294
43295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43296   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43297
43298   arg1 = (Dali::Path::Property *)jarg1;
43299   {
43300     try {
43301       delete arg1;
43302     } catch (std::out_of_range& e) {
43303       {
43304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43305       };
43306     } catch (std::exception& e) {
43307       {
43308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43309       };
43310     } catch (Dali::DaliException e) {
43311       {
43312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43313       };
43314     } catch (...) {
43315       {
43316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43317       };
43318     }
43319   }
43320
43321 }
43322
43323
43324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43325   void * jresult ;
43326   Dali::Path result;
43327
43328   {
43329     try {
43330       result = Dali::Path::New();
43331     } catch (std::out_of_range& e) {
43332       {
43333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43334       };
43335     } catch (std::exception& e) {
43336       {
43337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43338       };
43339     } catch (Dali::DaliException e) {
43340       {
43341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43342       };
43343     } catch (...) {
43344       {
43345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43346       };
43347     }
43348   }
43349
43350   jresult = new Dali::Path((const Dali::Path &)result);
43351   return jresult;
43352 }
43353
43354
43355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43356   void * jresult ;
43357   Dali::BaseHandle arg1 ;
43358   Dali::BaseHandle *argp1 ;
43359   Dali::Path result;
43360
43361   argp1 = (Dali::BaseHandle *)jarg1;
43362   if (!argp1) {
43363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43364     return 0;
43365   }
43366   arg1 = *argp1;
43367   {
43368     try {
43369       result = Dali::Path::DownCast(arg1);
43370     } catch (std::out_of_range& e) {
43371       {
43372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43373       };
43374     } catch (std::exception& e) {
43375       {
43376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43377       };
43378     } catch (Dali::DaliException e) {
43379       {
43380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43381       };
43382     } catch (...) {
43383       {
43384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43385       };
43386     }
43387   }
43388
43389   jresult = new Dali::Path((const Dali::Path &)result);
43390   return jresult;
43391 }
43392
43393
43394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43395   void * jresult ;
43396   Dali::Path *result = 0 ;
43397
43398   {
43399     try {
43400       result = (Dali::Path *)new Dali::Path();
43401     } catch (std::out_of_range& e) {
43402       {
43403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43404       };
43405     } catch (std::exception& e) {
43406       {
43407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43408       };
43409     } catch (Dali::DaliException e) {
43410       {
43411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43412       };
43413     } catch (...) {
43414       {
43415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43416       };
43417     }
43418   }
43419
43420   jresult = (void *)result;
43421   return jresult;
43422 }
43423
43424
43425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43426   Dali::Path *arg1 = (Dali::Path *) 0 ;
43427
43428   arg1 = (Dali::Path *)jarg1;
43429   {
43430     try {
43431       delete arg1;
43432     } catch (std::out_of_range& e) {
43433       {
43434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43435       };
43436     } catch (std::exception& e) {
43437       {
43438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43439       };
43440     } catch (Dali::DaliException e) {
43441       {
43442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43443       };
43444     } catch (...) {
43445       {
43446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43447       };
43448     }
43449   }
43450
43451 }
43452
43453
43454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43455   void * jresult ;
43456   Dali::Path *arg1 = 0 ;
43457   Dali::Path *result = 0 ;
43458
43459   arg1 = (Dali::Path *)jarg1;
43460   if (!arg1) {
43461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43462     return 0;
43463   }
43464   {
43465     try {
43466       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43467     } catch (std::out_of_range& e) {
43468       {
43469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43470       };
43471     } catch (std::exception& e) {
43472       {
43473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43474       };
43475     } catch (Dali::DaliException e) {
43476       {
43477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43478       };
43479     } catch (...) {
43480       {
43481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43482       };
43483     }
43484   }
43485
43486   jresult = (void *)result;
43487   return jresult;
43488 }
43489
43490
43491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43492   void * jresult ;
43493   Dali::Path *arg1 = (Dali::Path *) 0 ;
43494   Dali::Path *arg2 = 0 ;
43495   Dali::Path *result = 0 ;
43496
43497   arg1 = (Dali::Path *)jarg1;
43498   arg2 = (Dali::Path *)jarg2;
43499   if (!arg2) {
43500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43501     return 0;
43502   }
43503   {
43504     try {
43505       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43506     } catch (std::out_of_range& e) {
43507       {
43508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43509       };
43510     } catch (std::exception& e) {
43511       {
43512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43513       };
43514     } catch (Dali::DaliException e) {
43515       {
43516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43517       };
43518     } catch (...) {
43519       {
43520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43521       };
43522     }
43523   }
43524
43525   jresult = (void *)result;
43526   return jresult;
43527 }
43528
43529
43530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43531   Dali::Path *arg1 = (Dali::Path *) 0 ;
43532   Dali::Vector3 *arg2 = 0 ;
43533
43534   arg1 = (Dali::Path *)jarg1;
43535   arg2 = (Dali::Vector3 *)jarg2;
43536   if (!arg2) {
43537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43538     return ;
43539   }
43540   {
43541     try {
43542       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43543     } catch (std::out_of_range& e) {
43544       {
43545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43546       };
43547     } catch (std::exception& e) {
43548       {
43549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43550       };
43551     } catch (Dali::DaliException e) {
43552       {
43553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43554       };
43555     } catch (...) {
43556       {
43557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43558       };
43559     }
43560   }
43561
43562 }
43563
43564
43565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43566   Dali::Path *arg1 = (Dali::Path *) 0 ;
43567   Dali::Vector3 *arg2 = 0 ;
43568
43569   arg1 = (Dali::Path *)jarg1;
43570   arg2 = (Dali::Vector3 *)jarg2;
43571   if (!arg2) {
43572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43573     return ;
43574   }
43575   {
43576     try {
43577       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43578     } catch (std::out_of_range& e) {
43579       {
43580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43581       };
43582     } catch (std::exception& e) {
43583       {
43584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43585       };
43586     } catch (Dali::DaliException e) {
43587       {
43588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43589       };
43590     } catch (...) {
43591       {
43592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43593       };
43594     }
43595   }
43596
43597 }
43598
43599
43600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43601   Dali::Path *arg1 = (Dali::Path *) 0 ;
43602   float arg2 ;
43603
43604   arg1 = (Dali::Path *)jarg1;
43605   arg2 = (float)jarg2;
43606   {
43607     try {
43608       (arg1)->GenerateControlPoints(arg2);
43609     } catch (std::out_of_range& e) {
43610       {
43611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43612       };
43613     } catch (std::exception& e) {
43614       {
43615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43616       };
43617     } catch (Dali::DaliException e) {
43618       {
43619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43620       };
43621     } catch (...) {
43622       {
43623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43624       };
43625     }
43626   }
43627
43628 }
43629
43630
43631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43632   Dali::Path *arg1 = (Dali::Path *) 0 ;
43633   float arg2 ;
43634   Dali::Vector3 *arg3 = 0 ;
43635   Dali::Vector3 *arg4 = 0 ;
43636
43637   arg1 = (Dali::Path *)jarg1;
43638   arg2 = (float)jarg2;
43639   arg3 = (Dali::Vector3 *)jarg3;
43640   if (!arg3) {
43641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43642     return ;
43643   }
43644   arg4 = (Dali::Vector3 *)jarg4;
43645   if (!arg4) {
43646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43647     return ;
43648   }
43649   {
43650     try {
43651       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43652     } catch (std::out_of_range& e) {
43653       {
43654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43655       };
43656     } catch (std::exception& e) {
43657       {
43658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43659       };
43660     } catch (Dali::DaliException e) {
43661       {
43662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43663       };
43664     } catch (...) {
43665       {
43666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43667       };
43668     }
43669   }
43670
43671 }
43672
43673
43674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43675   void * jresult ;
43676   Dali::Path *arg1 = (Dali::Path *) 0 ;
43677   size_t arg2 ;
43678   Dali::Vector3 *result = 0 ;
43679
43680   arg1 = (Dali::Path *)jarg1;
43681   arg2 = (size_t)jarg2;
43682   {
43683     try {
43684       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43685     } catch (std::out_of_range& e) {
43686       {
43687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43688       };
43689     } catch (std::exception& e) {
43690       {
43691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43692       };
43693     } catch (Dali::DaliException e) {
43694       {
43695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43696       };
43697     } catch (...) {
43698       {
43699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43700       };
43701     }
43702   }
43703
43704   jresult = (void *)result;
43705   return jresult;
43706 }
43707
43708
43709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43710   void * jresult ;
43711   Dali::Path *arg1 = (Dali::Path *) 0 ;
43712   size_t arg2 ;
43713   Dali::Vector3 *result = 0 ;
43714
43715   arg1 = (Dali::Path *)jarg1;
43716   arg2 = (size_t)jarg2;
43717   {
43718     try {
43719       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43720     } catch (std::out_of_range& e) {
43721       {
43722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43723       };
43724     } catch (std::exception& e) {
43725       {
43726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43727       };
43728     } catch (Dali::DaliException e) {
43729       {
43730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43731       };
43732     } catch (...) {
43733       {
43734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43735       };
43736     }
43737   }
43738
43739   jresult = (void *)result;
43740   return jresult;
43741 }
43742
43743
43744 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43745   unsigned long jresult ;
43746   Dali::Path *arg1 = (Dali::Path *) 0 ;
43747   size_t result;
43748
43749   arg1 = (Dali::Path *)jarg1;
43750   {
43751     try {
43752       result = ((Dali::Path const *)arg1)->GetPointCount();
43753     } catch (std::out_of_range& e) {
43754       {
43755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43756       };
43757     } catch (std::exception& e) {
43758       {
43759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43760       };
43761     } catch (Dali::DaliException e) {
43762       {
43763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43764       };
43765     } catch (...) {
43766       {
43767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43768       };
43769     }
43770   }
43771
43772   jresult = (unsigned long)result;
43773   return jresult;
43774 }
43775
43776
43777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43778   void * jresult ;
43779   float arg1 ;
43780   Dali::TimePeriod *result = 0 ;
43781
43782   arg1 = (float)jarg1;
43783   {
43784     try {
43785       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43786     } catch (std::out_of_range& e) {
43787       {
43788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43789       };
43790     } catch (std::exception& e) {
43791       {
43792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43793       };
43794     } catch (Dali::DaliException e) {
43795       {
43796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43797       };
43798     } catch (...) {
43799       {
43800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43801       };
43802     }
43803   }
43804
43805   jresult = (void *)result;
43806   return jresult;
43807 }
43808
43809
43810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43811   void * jresult ;
43812   float arg1 ;
43813   float arg2 ;
43814   Dali::TimePeriod *result = 0 ;
43815
43816   arg1 = (float)jarg1;
43817   arg2 = (float)jarg2;
43818   {
43819     try {
43820       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43821     } catch (std::out_of_range& e) {
43822       {
43823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43824       };
43825     } catch (std::exception& e) {
43826       {
43827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43828       };
43829     } catch (Dali::DaliException e) {
43830       {
43831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43832       };
43833     } catch (...) {
43834       {
43835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43836       };
43837     }
43838   }
43839
43840   jresult = (void *)result;
43841   return jresult;
43842 }
43843
43844
43845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43846   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43847
43848   arg1 = (Dali::TimePeriod *)jarg1;
43849   {
43850     try {
43851       delete arg1;
43852     } catch (std::out_of_range& e) {
43853       {
43854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43855       };
43856     } catch (std::exception& e) {
43857       {
43858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43859       };
43860     } catch (Dali::DaliException e) {
43861       {
43862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43863       };
43864     } catch (...) {
43865       {
43866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43867       };
43868     }
43869   }
43870
43871 }
43872
43873
43874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43875   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43876   float arg2 ;
43877
43878   arg1 = (Dali::TimePeriod *)jarg1;
43879   arg2 = (float)jarg2;
43880   if (arg1) (arg1)->delaySeconds = arg2;
43881 }
43882
43883
43884 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43885   float jresult ;
43886   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43887   float result;
43888
43889   arg1 = (Dali::TimePeriod *)jarg1;
43890   result = (float) ((arg1)->delaySeconds);
43891   jresult = result;
43892   return jresult;
43893 }
43894
43895
43896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43897   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43898   float arg2 ;
43899
43900   arg1 = (Dali::TimePeriod *)jarg1;
43901   arg2 = (float)jarg2;
43902   if (arg1) (arg1)->durationSeconds = arg2;
43903 }
43904
43905
43906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43907   float jresult ;
43908   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43909   float result;
43910
43911   arg1 = (Dali::TimePeriod *)jarg1;
43912   result = (float) ((arg1)->durationSeconds);
43913   jresult = result;
43914   return jresult;
43915 }
43916
43917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43918   int jresult ;
43919   int result;
43920
43921   result = (int)Dali::LinearConstrainer::Property::VALUE;
43922   jresult = (int)result;
43923   return jresult;
43924 }
43925
43926
43927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43928   int jresult ;
43929   int result;
43930
43931   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43932   jresult = (int)result;
43933   return jresult;
43934 }
43935
43936
43937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43938   void * jresult ;
43939   Dali::LinearConstrainer::Property *result = 0 ;
43940
43941   {
43942     try {
43943       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43944     } catch (std::out_of_range& e) {
43945       {
43946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43947       };
43948     } catch (std::exception& e) {
43949       {
43950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43951       };
43952     } catch (Dali::DaliException e) {
43953       {
43954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43955       };
43956     } catch (...) {
43957       {
43958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43959       };
43960     }
43961   }
43962
43963   jresult = (void *)result;
43964   return jresult;
43965 }
43966
43967
43968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43969   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43970
43971   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43972   {
43973     try {
43974       delete arg1;
43975     } catch (std::out_of_range& e) {
43976       {
43977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43978       };
43979     } catch (std::exception& e) {
43980       {
43981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43982       };
43983     } catch (Dali::DaliException e) {
43984       {
43985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43986       };
43987     } catch (...) {
43988       {
43989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43990       };
43991     }
43992   }
43993
43994 }
43995
43996
43997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43998   void * jresult ;
43999   Dali::LinearConstrainer result;
44000
44001   {
44002     try {
44003       result = Dali::LinearConstrainer::New();
44004     } catch (std::out_of_range& e) {
44005       {
44006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44007       };
44008     } catch (std::exception& e) {
44009       {
44010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44011       };
44012     } catch (Dali::DaliException e) {
44013       {
44014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44015       };
44016     } catch (...) {
44017       {
44018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44019       };
44020     }
44021   }
44022
44023   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44024   return jresult;
44025 }
44026
44027
44028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44029   void * jresult ;
44030   Dali::BaseHandle arg1 ;
44031   Dali::BaseHandle *argp1 ;
44032   Dali::LinearConstrainer result;
44033
44034   argp1 = (Dali::BaseHandle *)jarg1;
44035   if (!argp1) {
44036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44037     return 0;
44038   }
44039   arg1 = *argp1;
44040   {
44041     try {
44042       result = Dali::LinearConstrainer::DownCast(arg1);
44043     } catch (std::out_of_range& e) {
44044       {
44045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44046       };
44047     } catch (std::exception& e) {
44048       {
44049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44050       };
44051     } catch (Dali::DaliException e) {
44052       {
44053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44054       };
44055     } catch (...) {
44056       {
44057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44058       };
44059     }
44060   }
44061
44062   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44063   return jresult;
44064 }
44065
44066
44067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44068   void * jresult ;
44069   Dali::LinearConstrainer *result = 0 ;
44070
44071   {
44072     try {
44073       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44074     } catch (std::out_of_range& e) {
44075       {
44076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44077       };
44078     } catch (std::exception& e) {
44079       {
44080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44081       };
44082     } catch (Dali::DaliException e) {
44083       {
44084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44085       };
44086     } catch (...) {
44087       {
44088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44089       };
44090     }
44091   }
44092
44093   jresult = (void *)result;
44094   return jresult;
44095 }
44096
44097
44098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44099   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44100
44101   arg1 = (Dali::LinearConstrainer *)jarg1;
44102   {
44103     try {
44104       delete arg1;
44105     } catch (std::out_of_range& e) {
44106       {
44107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44108       };
44109     } catch (std::exception& e) {
44110       {
44111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44112       };
44113     } catch (Dali::DaliException e) {
44114       {
44115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44116       };
44117     } catch (...) {
44118       {
44119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44120       };
44121     }
44122   }
44123
44124 }
44125
44126
44127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44128   void * jresult ;
44129   Dali::LinearConstrainer *arg1 = 0 ;
44130   Dali::LinearConstrainer *result = 0 ;
44131
44132   arg1 = (Dali::LinearConstrainer *)jarg1;
44133   if (!arg1) {
44134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44135     return 0;
44136   }
44137   {
44138     try {
44139       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44140     } catch (std::out_of_range& e) {
44141       {
44142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44143       };
44144     } catch (std::exception& e) {
44145       {
44146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44147       };
44148     } catch (Dali::DaliException e) {
44149       {
44150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44151       };
44152     } catch (...) {
44153       {
44154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44155       };
44156     }
44157   }
44158
44159   jresult = (void *)result;
44160   return jresult;
44161 }
44162
44163
44164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44165   void * jresult ;
44166   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44167   Dali::LinearConstrainer *arg2 = 0 ;
44168   Dali::LinearConstrainer *result = 0 ;
44169
44170   arg1 = (Dali::LinearConstrainer *)jarg1;
44171   arg2 = (Dali::LinearConstrainer *)jarg2;
44172   if (!arg2) {
44173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44174     return 0;
44175   }
44176   {
44177     try {
44178       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44179     } catch (std::out_of_range& e) {
44180       {
44181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44182       };
44183     } catch (std::exception& e) {
44184       {
44185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44186       };
44187     } catch (Dali::DaliException e) {
44188       {
44189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44190       };
44191     } catch (...) {
44192       {
44193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44194       };
44195     }
44196   }
44197
44198   jresult = (void *)result;
44199   return jresult;
44200 }
44201
44202
44203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44204   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44205   SwigValueWrapper< Dali::Property > arg2 ;
44206   SwigValueWrapper< Dali::Property > arg3 ;
44207   Dali::Vector2 *arg4 = 0 ;
44208   Dali::Vector2 *arg5 = 0 ;
44209   Dali::Property *argp2 ;
44210   Dali::Property *argp3 ;
44211
44212   arg1 = (Dali::LinearConstrainer *)jarg1;
44213   argp2 = (Dali::Property *)jarg2;
44214   if (!argp2) {
44215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44216     return ;
44217   }
44218   arg2 = *argp2;
44219   argp3 = (Dali::Property *)jarg3;
44220   if (!argp3) {
44221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44222     return ;
44223   }
44224   arg3 = *argp3;
44225   arg4 = (Dali::Vector2 *)jarg4;
44226   if (!arg4) {
44227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44228     return ;
44229   }
44230   arg5 = (Dali::Vector2 *)jarg5;
44231   if (!arg5) {
44232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44233     return ;
44234   }
44235   {
44236     try {
44237       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44238     } catch (std::out_of_range& e) {
44239       {
44240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44241       };
44242     } catch (std::exception& e) {
44243       {
44244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44245       };
44246     } catch (Dali::DaliException e) {
44247       {
44248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44249       };
44250     } catch (...) {
44251       {
44252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44253       };
44254     }
44255   }
44256
44257 }
44258
44259
44260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44261   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44262   SwigValueWrapper< Dali::Property > arg2 ;
44263   SwigValueWrapper< Dali::Property > arg3 ;
44264   Dali::Vector2 *arg4 = 0 ;
44265   Dali::Property *argp2 ;
44266   Dali::Property *argp3 ;
44267
44268   arg1 = (Dali::LinearConstrainer *)jarg1;
44269   argp2 = (Dali::Property *)jarg2;
44270   if (!argp2) {
44271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44272     return ;
44273   }
44274   arg2 = *argp2;
44275   argp3 = (Dali::Property *)jarg3;
44276   if (!argp3) {
44277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44278     return ;
44279   }
44280   arg3 = *argp3;
44281   arg4 = (Dali::Vector2 *)jarg4;
44282   if (!arg4) {
44283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44284     return ;
44285   }
44286   {
44287     try {
44288       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44289     } catch (std::out_of_range& e) {
44290       {
44291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44292       };
44293     } catch (std::exception& e) {
44294       {
44295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44296       };
44297     } catch (Dali::DaliException e) {
44298       {
44299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44300       };
44301     } catch (...) {
44302       {
44303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44304       };
44305     }
44306   }
44307
44308 }
44309
44310
44311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44312   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44313   Dali::Handle *arg2 = 0 ;
44314
44315   arg1 = (Dali::LinearConstrainer *)jarg1;
44316   arg2 = (Dali::Handle *)jarg2;
44317   if (!arg2) {
44318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44319     return ;
44320   }
44321   {
44322     try {
44323       (arg1)->Remove(*arg2);
44324     } catch (std::out_of_range& e) {
44325       {
44326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44327       };
44328     } catch (std::exception& e) {
44329       {
44330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44331       };
44332     } catch (Dali::DaliException e) {
44333       {
44334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44335       };
44336     } catch (...) {
44337       {
44338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44339       };
44340     }
44341   }
44342
44343 }
44344
44345
44346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44347   int jresult ;
44348   int result;
44349
44350   result = (int)Dali::PathConstrainer::Property::FORWARD;
44351   jresult = (int)result;
44352   return jresult;
44353 }
44354
44355
44356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44357   int jresult ;
44358   int result;
44359
44360   result = (int)Dali::PathConstrainer::Property::POINTS;
44361   jresult = (int)result;
44362   return jresult;
44363 }
44364
44365
44366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44367   int jresult ;
44368   int result;
44369
44370   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44371   jresult = (int)result;
44372   return jresult;
44373 }
44374
44375
44376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44377   void * jresult ;
44378   Dali::PathConstrainer::Property *result = 0 ;
44379
44380   {
44381     try {
44382       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44383     } catch (std::out_of_range& e) {
44384       {
44385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44386       };
44387     } catch (std::exception& e) {
44388       {
44389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44390       };
44391     } catch (Dali::DaliException e) {
44392       {
44393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44394       };
44395     } catch (...) {
44396       {
44397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44398       };
44399     }
44400   }
44401
44402   jresult = (void *)result;
44403   return jresult;
44404 }
44405
44406
44407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44408   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44409
44410   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44411   {
44412     try {
44413       delete arg1;
44414     } catch (std::out_of_range& e) {
44415       {
44416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44417       };
44418     } catch (std::exception& e) {
44419       {
44420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44421       };
44422     } catch (Dali::DaliException e) {
44423       {
44424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44425       };
44426     } catch (...) {
44427       {
44428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44429       };
44430     }
44431   }
44432
44433 }
44434
44435
44436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44437   void * jresult ;
44438   Dali::PathConstrainer result;
44439
44440   {
44441     try {
44442       result = Dali::PathConstrainer::New();
44443     } catch (std::out_of_range& e) {
44444       {
44445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44446       };
44447     } catch (std::exception& e) {
44448       {
44449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44450       };
44451     } catch (Dali::DaliException e) {
44452       {
44453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44454       };
44455     } catch (...) {
44456       {
44457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44458       };
44459     }
44460   }
44461
44462   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44463   return jresult;
44464 }
44465
44466
44467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44468   void * jresult ;
44469   Dali::BaseHandle arg1 ;
44470   Dali::BaseHandle *argp1 ;
44471   Dali::PathConstrainer result;
44472
44473   argp1 = (Dali::BaseHandle *)jarg1;
44474   if (!argp1) {
44475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44476     return 0;
44477   }
44478   arg1 = *argp1;
44479   {
44480     try {
44481       result = Dali::PathConstrainer::DownCast(arg1);
44482     } catch (std::out_of_range& e) {
44483       {
44484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44485       };
44486     } catch (std::exception& e) {
44487       {
44488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44489       };
44490     } catch (Dali::DaliException e) {
44491       {
44492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44493       };
44494     } catch (...) {
44495       {
44496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44497       };
44498     }
44499   }
44500
44501   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44502   return jresult;
44503 }
44504
44505
44506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44507   void * jresult ;
44508   Dali::PathConstrainer *result = 0 ;
44509
44510   {
44511     try {
44512       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44513     } catch (std::out_of_range& e) {
44514       {
44515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44516       };
44517     } catch (std::exception& e) {
44518       {
44519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44520       };
44521     } catch (Dali::DaliException e) {
44522       {
44523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44524       };
44525     } catch (...) {
44526       {
44527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44528       };
44529     }
44530   }
44531
44532   jresult = (void *)result;
44533   return jresult;
44534 }
44535
44536
44537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44538   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44539
44540   arg1 = (Dali::PathConstrainer *)jarg1;
44541   {
44542     try {
44543       delete arg1;
44544     } catch (std::out_of_range& e) {
44545       {
44546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44547       };
44548     } catch (std::exception& e) {
44549       {
44550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44551       };
44552     } catch (Dali::DaliException e) {
44553       {
44554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44555       };
44556     } catch (...) {
44557       {
44558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44559       };
44560     }
44561   }
44562
44563 }
44564
44565
44566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44567   void * jresult ;
44568   Dali::PathConstrainer *arg1 = 0 ;
44569   Dali::PathConstrainer *result = 0 ;
44570
44571   arg1 = (Dali::PathConstrainer *)jarg1;
44572   if (!arg1) {
44573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44574     return 0;
44575   }
44576   {
44577     try {
44578       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44579     } catch (std::out_of_range& e) {
44580       {
44581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44582       };
44583     } catch (std::exception& e) {
44584       {
44585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44586       };
44587     } catch (Dali::DaliException e) {
44588       {
44589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44590       };
44591     } catch (...) {
44592       {
44593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44594       };
44595     }
44596   }
44597
44598   jresult = (void *)result;
44599   return jresult;
44600 }
44601
44602
44603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44604   void * jresult ;
44605   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44606   Dali::PathConstrainer *arg2 = 0 ;
44607   Dali::PathConstrainer *result = 0 ;
44608
44609   arg1 = (Dali::PathConstrainer *)jarg1;
44610   arg2 = (Dali::PathConstrainer *)jarg2;
44611   if (!arg2) {
44612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44613     return 0;
44614   }
44615   {
44616     try {
44617       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44618     } catch (std::out_of_range& e) {
44619       {
44620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44621       };
44622     } catch (std::exception& e) {
44623       {
44624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44625       };
44626     } catch (Dali::DaliException e) {
44627       {
44628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44629       };
44630     } catch (...) {
44631       {
44632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44633       };
44634     }
44635   }
44636
44637   jresult = (void *)result;
44638   return jresult;
44639 }
44640
44641
44642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44643   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44644   SwigValueWrapper< Dali::Property > arg2 ;
44645   SwigValueWrapper< Dali::Property > arg3 ;
44646   Dali::Vector2 *arg4 = 0 ;
44647   Dali::Vector2 *arg5 = 0 ;
44648   Dali::Property *argp2 ;
44649   Dali::Property *argp3 ;
44650
44651   arg1 = (Dali::PathConstrainer *)jarg1;
44652   argp2 = (Dali::Property *)jarg2;
44653   if (!argp2) {
44654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44655     return ;
44656   }
44657   arg2 = *argp2;
44658   argp3 = (Dali::Property *)jarg3;
44659   if (!argp3) {
44660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44661     return ;
44662   }
44663   arg3 = *argp3;
44664   arg4 = (Dali::Vector2 *)jarg4;
44665   if (!arg4) {
44666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44667     return ;
44668   }
44669   arg5 = (Dali::Vector2 *)jarg5;
44670   if (!arg5) {
44671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44672     return ;
44673   }
44674   {
44675     try {
44676       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44677     } catch (std::out_of_range& e) {
44678       {
44679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44680       };
44681     } catch (std::exception& e) {
44682       {
44683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44684       };
44685     } catch (Dali::DaliException e) {
44686       {
44687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44688       };
44689     } catch (...) {
44690       {
44691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44692       };
44693     }
44694   }
44695
44696 }
44697
44698
44699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44700   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44701   SwigValueWrapper< Dali::Property > arg2 ;
44702   SwigValueWrapper< Dali::Property > arg3 ;
44703   Dali::Vector2 *arg4 = 0 ;
44704   Dali::Property *argp2 ;
44705   Dali::Property *argp3 ;
44706
44707   arg1 = (Dali::PathConstrainer *)jarg1;
44708   argp2 = (Dali::Property *)jarg2;
44709   if (!argp2) {
44710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44711     return ;
44712   }
44713   arg2 = *argp2;
44714   argp3 = (Dali::Property *)jarg3;
44715   if (!argp3) {
44716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44717     return ;
44718   }
44719   arg3 = *argp3;
44720   arg4 = (Dali::Vector2 *)jarg4;
44721   if (!arg4) {
44722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44723     return ;
44724   }
44725   {
44726     try {
44727       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44728     } catch (std::out_of_range& e) {
44729       {
44730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44731       };
44732     } catch (std::exception& e) {
44733       {
44734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44735       };
44736     } catch (Dali::DaliException e) {
44737       {
44738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44739       };
44740     } catch (...) {
44741       {
44742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44743       };
44744     }
44745   }
44746
44747 }
44748
44749
44750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44751   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44752   Dali::Handle *arg2 = 0 ;
44753
44754   arg1 = (Dali::PathConstrainer *)jarg1;
44755   arg2 = (Dali::Handle *)jarg2;
44756   if (!arg2) {
44757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44758     return ;
44759   }
44760   {
44761     try {
44762       (arg1)->Remove(*arg2);
44763     } catch (std::out_of_range& e) {
44764       {
44765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44766       };
44767     } catch (std::exception& e) {
44768       {
44769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44770       };
44771     } catch (Dali::DaliException e) {
44772       {
44773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44774       };
44775     } catch (...) {
44776       {
44777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44778       };
44779     }
44780   }
44781
44782 }
44783
44784
44785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44786   int jresult ;
44787   Dali::FittingMode::Type result;
44788
44789   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44790   jresult = (int)result;
44791   return jresult;
44792 }
44793
44794
44795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44796   int jresult ;
44797   Dali::SamplingMode::Type result;
44798
44799   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44800   jresult = (int)result;
44801   return jresult;
44802 }
44803
44804
44805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
44806   unsigned int jresult ;
44807   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44808   bool result;
44809
44810   arg1 = (Dali::NativeImageInterface *)jarg1;
44811   {
44812     try {
44813       result = (bool)(arg1)->GlExtensionCreate();
44814     } catch (std::out_of_range& e) {
44815       {
44816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44817       };
44818     } catch (std::exception& e) {
44819       {
44820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44821       };
44822     } catch (Dali::DaliException e) {
44823       {
44824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44825       };
44826     } catch (...) {
44827       {
44828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44829       };
44830     }
44831   }
44832
44833   jresult = result;
44834   return jresult;
44835 }
44836
44837
44838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
44839   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44840
44841   arg1 = (Dali::NativeImageInterface *)jarg1;
44842   {
44843     try {
44844       (arg1)->GlExtensionDestroy();
44845     } catch (std::out_of_range& e) {
44846       {
44847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44848       };
44849     } catch (std::exception& e) {
44850       {
44851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44852       };
44853     } catch (Dali::DaliException e) {
44854       {
44855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44856       };
44857     } catch (...) {
44858       {
44859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44860       };
44861     }
44862   }
44863
44864 }
44865
44866
44867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44868   unsigned int jresult ;
44869   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44870   unsigned int result;
44871
44872   arg1 = (Dali::NativeImageInterface *)jarg1;
44873   {
44874     try {
44875       result = (unsigned int)(arg1)->TargetTexture();
44876     } catch (std::out_of_range& e) {
44877       {
44878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44879       };
44880     } catch (std::exception& e) {
44881       {
44882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44883       };
44884     } catch (Dali::DaliException e) {
44885       {
44886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44887       };
44888     } catch (...) {
44889       {
44890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44891       };
44892     }
44893   }
44894
44895   jresult = result;
44896   return jresult;
44897 }
44898
44899
44900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44901   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44902
44903   arg1 = (Dali::NativeImageInterface *)jarg1;
44904   {
44905     try {
44906       (arg1)->PrepareTexture();
44907     } catch (std::out_of_range& e) {
44908       {
44909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44910       };
44911     } catch (std::exception& e) {
44912       {
44913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44914       };
44915     } catch (Dali::DaliException e) {
44916       {
44917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44918       };
44919     } catch (...) {
44920       {
44921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44922       };
44923     }
44924   }
44925
44926 }
44927
44928
44929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44930   unsigned int jresult ;
44931   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44932   unsigned int result;
44933
44934   arg1 = (Dali::NativeImageInterface *)jarg1;
44935   {
44936     try {
44937       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44938     } catch (std::out_of_range& e) {
44939       {
44940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44941       };
44942     } catch (std::exception& e) {
44943       {
44944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44945       };
44946     } catch (Dali::DaliException e) {
44947       {
44948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44949       };
44950     } catch (...) {
44951       {
44952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44953       };
44954     }
44955   }
44956
44957   jresult = result;
44958   return jresult;
44959 }
44960
44961
44962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44963   unsigned int jresult ;
44964   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44965   unsigned int result;
44966
44967   arg1 = (Dali::NativeImageInterface *)jarg1;
44968   {
44969     try {
44970       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44971     } catch (std::out_of_range& e) {
44972       {
44973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44974       };
44975     } catch (std::exception& e) {
44976       {
44977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44978       };
44979     } catch (Dali::DaliException e) {
44980       {
44981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44982       };
44983     } catch (...) {
44984       {
44985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44986       };
44987     }
44988   }
44989
44990   jresult = result;
44991   return jresult;
44992 }
44993
44994
44995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44996   unsigned int jresult ;
44997   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44998   bool result;
44999
45000   arg1 = (Dali::NativeImageInterface *)jarg1;
45001   {
45002     try {
45003       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
45004     } catch (std::out_of_range& e) {
45005       {
45006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45007       };
45008     } catch (std::exception& e) {
45009       {
45010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45011       };
45012     } catch (Dali::DaliException e) {
45013       {
45014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45015       };
45016     } catch (...) {
45017       {
45018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45019       };
45020     }
45021   }
45022
45023   jresult = result;
45024   return jresult;
45025 }
45026
45027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
45028   int jresult ;
45029   int result;
45030
45031   result = (int)Dali::CameraActor::Property::TYPE;
45032   jresult = (int)result;
45033   return jresult;
45034 }
45035
45036
45037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
45038   int jresult ;
45039   int result;
45040
45041   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
45042   jresult = (int)result;
45043   return jresult;
45044 }
45045
45046
45047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
45048   int jresult ;
45049   int result;
45050
45051   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
45052   jresult = (int)result;
45053   return jresult;
45054 }
45055
45056
45057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
45058   int jresult ;
45059   int result;
45060
45061   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
45062   jresult = (int)result;
45063   return jresult;
45064 }
45065
45066
45067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
45068   int jresult ;
45069   int result;
45070
45071   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
45072   jresult = (int)result;
45073   return jresult;
45074 }
45075
45076
45077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
45078   int jresult ;
45079   int result;
45080
45081   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
45082   jresult = (int)result;
45083   return jresult;
45084 }
45085
45086
45087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
45088   int jresult ;
45089   int result;
45090
45091   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
45092   jresult = (int)result;
45093   return jresult;
45094 }
45095
45096
45097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
45098   int jresult ;
45099   int result;
45100
45101   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
45102   jresult = (int)result;
45103   return jresult;
45104 }
45105
45106
45107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
45108   int jresult ;
45109   int result;
45110
45111   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
45112   jresult = (int)result;
45113   return jresult;
45114 }
45115
45116
45117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
45118   int jresult ;
45119   int result;
45120
45121   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
45122   jresult = (int)result;
45123   return jresult;
45124 }
45125
45126
45127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
45128   int jresult ;
45129   int result;
45130
45131   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
45132   jresult = (int)result;
45133   return jresult;
45134 }
45135
45136
45137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
45138   int jresult ;
45139   int result;
45140
45141   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
45142   jresult = (int)result;
45143   return jresult;
45144 }
45145
45146
45147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
45148   int jresult ;
45149   int result;
45150
45151   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
45152   jresult = (int)result;
45153   return jresult;
45154 }
45155
45156
45157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
45158   int jresult ;
45159   int result;
45160
45161   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
45162   jresult = (int)result;
45163   return jresult;
45164 }
45165
45166
45167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
45168   void * jresult ;
45169   Dali::CameraActor::Property *result = 0 ;
45170
45171   {
45172     try {
45173       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
45174     } catch (std::out_of_range& e) {
45175       {
45176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45177       };
45178     } catch (std::exception& e) {
45179       {
45180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45181       };
45182     } catch (Dali::DaliException e) {
45183       {
45184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45185       };
45186     } catch (...) {
45187       {
45188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45189       };
45190     }
45191   }
45192
45193   jresult = (void *)result;
45194   return jresult;
45195 }
45196
45197
45198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
45199   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
45200
45201   arg1 = (Dali::CameraActor::Property *)jarg1;
45202   {
45203     try {
45204       delete arg1;
45205     } catch (std::out_of_range& e) {
45206       {
45207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45208       };
45209     } catch (std::exception& e) {
45210       {
45211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45212       };
45213     } catch (Dali::DaliException e) {
45214       {
45215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45216       };
45217     } catch (...) {
45218       {
45219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45220       };
45221     }
45222   }
45223
45224 }
45225
45226
45227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
45228   void * jresult ;
45229   Dali::CameraActor *result = 0 ;
45230
45231   {
45232     try {
45233       result = (Dali::CameraActor *)new Dali::CameraActor();
45234     } catch (std::out_of_range& e) {
45235       {
45236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45237       };
45238     } catch (std::exception& e) {
45239       {
45240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45241       };
45242     } catch (Dali::DaliException e) {
45243       {
45244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45245       };
45246     } catch (...) {
45247       {
45248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45249       };
45250     }
45251   }
45252
45253   jresult = (void *)result;
45254   return jresult;
45255 }
45256
45257
45258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
45259   void * jresult ;
45260   Dali::CameraActor result;
45261
45262   {
45263     try {
45264       result = Dali::CameraActor::New();
45265     } catch (std::out_of_range& e) {
45266       {
45267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45268       };
45269     } catch (std::exception& e) {
45270       {
45271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45272       };
45273     } catch (Dali::DaliException e) {
45274       {
45275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45276       };
45277     } catch (...) {
45278       {
45279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45280       };
45281     }
45282   }
45283
45284   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45285   return jresult;
45286 }
45287
45288
45289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
45290   void * jresult ;
45291   Dali::Size *arg1 = 0 ;
45292   Dali::CameraActor result;
45293
45294   arg1 = (Dali::Size *)jarg1;
45295   if (!arg1) {
45296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45297     return 0;
45298   }
45299   {
45300     try {
45301       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
45302     } catch (std::out_of_range& e) {
45303       {
45304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45305       };
45306     } catch (std::exception& e) {
45307       {
45308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45309       };
45310     } catch (Dali::DaliException e) {
45311       {
45312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45313       };
45314     } catch (...) {
45315       {
45316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45317       };
45318     }
45319   }
45320
45321   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45322   return jresult;
45323 }
45324
45325
45326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
45327   void * jresult ;
45328   Dali::BaseHandle arg1 ;
45329   Dali::BaseHandle *argp1 ;
45330   Dali::CameraActor result;
45331
45332   argp1 = (Dali::BaseHandle *)jarg1;
45333   if (!argp1) {
45334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45335     return 0;
45336   }
45337   arg1 = *argp1;
45338   {
45339     try {
45340       result = Dali::CameraActor::DownCast(arg1);
45341     } catch (std::out_of_range& e) {
45342       {
45343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45344       };
45345     } catch (std::exception& e) {
45346       {
45347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45348       };
45349     } catch (Dali::DaliException e) {
45350       {
45351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45352       };
45353     } catch (...) {
45354       {
45355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45356       };
45357     }
45358   }
45359
45360   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45361   return jresult;
45362 }
45363
45364
45365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
45366   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45367
45368   arg1 = (Dali::CameraActor *)jarg1;
45369   {
45370     try {
45371       delete arg1;
45372     } catch (std::out_of_range& e) {
45373       {
45374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45375       };
45376     } catch (std::exception& e) {
45377       {
45378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45379       };
45380     } catch (Dali::DaliException e) {
45381       {
45382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45383       };
45384     } catch (...) {
45385       {
45386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45387       };
45388     }
45389   }
45390
45391 }
45392
45393
45394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
45395   void * jresult ;
45396   Dali::CameraActor *arg1 = 0 ;
45397   Dali::CameraActor *result = 0 ;
45398
45399   arg1 = (Dali::CameraActor *)jarg1;
45400   if (!arg1) {
45401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45402     return 0;
45403   }
45404   {
45405     try {
45406       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
45407     } catch (std::out_of_range& e) {
45408       {
45409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45410       };
45411     } catch (std::exception& e) {
45412       {
45413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45414       };
45415     } catch (Dali::DaliException e) {
45416       {
45417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45418       };
45419     } catch (...) {
45420       {
45421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45422       };
45423     }
45424   }
45425
45426   jresult = (void *)result;
45427   return jresult;
45428 }
45429
45430
45431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
45432   void * jresult ;
45433   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45434   Dali::CameraActor *arg2 = 0 ;
45435   Dali::CameraActor *result = 0 ;
45436
45437   arg1 = (Dali::CameraActor *)jarg1;
45438   arg2 = (Dali::CameraActor *)jarg2;
45439   if (!arg2) {
45440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45441     return 0;
45442   }
45443   {
45444     try {
45445       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
45446     } catch (std::out_of_range& e) {
45447       {
45448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45449       };
45450     } catch (std::exception& e) {
45451       {
45452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45453       };
45454     } catch (Dali::DaliException e) {
45455       {
45456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45457       };
45458     } catch (...) {
45459       {
45460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45461       };
45462     }
45463   }
45464
45465   jresult = (void *)result;
45466   return jresult;
45467 }
45468
45469
45470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
45471   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45472   Dali::Camera::Type arg2 ;
45473
45474   arg1 = (Dali::CameraActor *)jarg1;
45475   arg2 = (Dali::Camera::Type)jarg2;
45476   {
45477     try {
45478       (arg1)->SetType(arg2);
45479     } catch (std::out_of_range& e) {
45480       {
45481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45482       };
45483     } catch (std::exception& e) {
45484       {
45485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45486       };
45487     } catch (Dali::DaliException e) {
45488       {
45489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45490       };
45491     } catch (...) {
45492       {
45493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45494       };
45495     }
45496   }
45497
45498 }
45499
45500
45501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
45502   int jresult ;
45503   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45504   Dali::Camera::Type result;
45505
45506   arg1 = (Dali::CameraActor *)jarg1;
45507   {
45508     try {
45509       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
45510     } catch (std::out_of_range& e) {
45511       {
45512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45513       };
45514     } catch (std::exception& e) {
45515       {
45516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45517       };
45518     } catch (Dali::DaliException e) {
45519       {
45520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45521       };
45522     } catch (...) {
45523       {
45524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45525       };
45526     }
45527   }
45528
45529   jresult = (int)result;
45530   return jresult;
45531 }
45532
45533
45534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45535   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45536   Dali::Camera::ProjectionMode arg2 ;
45537
45538   arg1 = (Dali::CameraActor *)jarg1;
45539   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45540   {
45541     try {
45542       (arg1)->SetProjectionMode(arg2);
45543     } catch (std::out_of_range& e) {
45544       {
45545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45546       };
45547     } catch (std::exception& e) {
45548       {
45549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45550       };
45551     } catch (Dali::DaliException e) {
45552       {
45553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45554       };
45555     } catch (...) {
45556       {
45557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45558       };
45559     }
45560   }
45561
45562 }
45563
45564
45565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45566   int jresult ;
45567   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45568   Dali::Camera::ProjectionMode result;
45569
45570   arg1 = (Dali::CameraActor *)jarg1;
45571   {
45572     try {
45573       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45574     } catch (std::out_of_range& e) {
45575       {
45576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45577       };
45578     } catch (std::exception& e) {
45579       {
45580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45581       };
45582     } catch (Dali::DaliException e) {
45583       {
45584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45585       };
45586     } catch (...) {
45587       {
45588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45589       };
45590     }
45591   }
45592
45593   jresult = (int)result;
45594   return jresult;
45595 }
45596
45597
45598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45599   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45600   float arg2 ;
45601
45602   arg1 = (Dali::CameraActor *)jarg1;
45603   arg2 = (float)jarg2;
45604   {
45605     try {
45606       (arg1)->SetFieldOfView(arg2);
45607     } catch (std::out_of_range& e) {
45608       {
45609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45610       };
45611     } catch (std::exception& e) {
45612       {
45613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45614       };
45615     } catch (Dali::DaliException e) {
45616       {
45617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45618       };
45619     } catch (...) {
45620       {
45621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45622       };
45623     }
45624   }
45625
45626 }
45627
45628
45629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45630   float jresult ;
45631   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45632   float result;
45633
45634   arg1 = (Dali::CameraActor *)jarg1;
45635   {
45636     try {
45637       result = (float)(arg1)->GetFieldOfView();
45638     } catch (std::out_of_range& e) {
45639       {
45640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45641       };
45642     } catch (std::exception& e) {
45643       {
45644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45645       };
45646     } catch (Dali::DaliException e) {
45647       {
45648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45649       };
45650     } catch (...) {
45651       {
45652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45653       };
45654     }
45655   }
45656
45657   jresult = result;
45658   return jresult;
45659 }
45660
45661
45662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45663   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45664   float arg2 ;
45665
45666   arg1 = (Dali::CameraActor *)jarg1;
45667   arg2 = (float)jarg2;
45668   {
45669     try {
45670       (arg1)->SetAspectRatio(arg2);
45671     } catch (std::out_of_range& e) {
45672       {
45673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45674       };
45675     } catch (std::exception& e) {
45676       {
45677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45678       };
45679     } catch (Dali::DaliException e) {
45680       {
45681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45682       };
45683     } catch (...) {
45684       {
45685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45686       };
45687     }
45688   }
45689
45690 }
45691
45692
45693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45694   float jresult ;
45695   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45696   float result;
45697
45698   arg1 = (Dali::CameraActor *)jarg1;
45699   {
45700     try {
45701       result = (float)(arg1)->GetAspectRatio();
45702     } catch (std::out_of_range& e) {
45703       {
45704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45705       };
45706     } catch (std::exception& e) {
45707       {
45708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45709       };
45710     } catch (Dali::DaliException e) {
45711       {
45712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45713       };
45714     } catch (...) {
45715       {
45716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45717       };
45718     }
45719   }
45720
45721   jresult = result;
45722   return jresult;
45723 }
45724
45725
45726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45727   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45728   float arg2 ;
45729
45730   arg1 = (Dali::CameraActor *)jarg1;
45731   arg2 = (float)jarg2;
45732   {
45733     try {
45734       (arg1)->SetNearClippingPlane(arg2);
45735     } catch (std::out_of_range& e) {
45736       {
45737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45738       };
45739     } catch (std::exception& e) {
45740       {
45741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45742       };
45743     } catch (Dali::DaliException e) {
45744       {
45745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45746       };
45747     } catch (...) {
45748       {
45749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45750       };
45751     }
45752   }
45753
45754 }
45755
45756
45757 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45758   float jresult ;
45759   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45760   float result;
45761
45762   arg1 = (Dali::CameraActor *)jarg1;
45763   {
45764     try {
45765       result = (float)(arg1)->GetNearClippingPlane();
45766     } catch (std::out_of_range& e) {
45767       {
45768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45769       };
45770     } catch (std::exception& e) {
45771       {
45772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45773       };
45774     } catch (Dali::DaliException e) {
45775       {
45776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45777       };
45778     } catch (...) {
45779       {
45780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45781       };
45782     }
45783   }
45784
45785   jresult = result;
45786   return jresult;
45787 }
45788
45789
45790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45791   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45792   float arg2 ;
45793
45794   arg1 = (Dali::CameraActor *)jarg1;
45795   arg2 = (float)jarg2;
45796   {
45797     try {
45798       (arg1)->SetFarClippingPlane(arg2);
45799     } catch (std::out_of_range& e) {
45800       {
45801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45802       };
45803     } catch (std::exception& e) {
45804       {
45805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45806       };
45807     } catch (Dali::DaliException e) {
45808       {
45809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45810       };
45811     } catch (...) {
45812       {
45813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45814       };
45815     }
45816   }
45817
45818 }
45819
45820
45821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45822   float jresult ;
45823   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45824   float result;
45825
45826   arg1 = (Dali::CameraActor *)jarg1;
45827   {
45828     try {
45829       result = (float)(arg1)->GetFarClippingPlane();
45830     } catch (std::out_of_range& e) {
45831       {
45832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45833       };
45834     } catch (std::exception& e) {
45835       {
45836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45837       };
45838     } catch (Dali::DaliException e) {
45839       {
45840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45841       };
45842     } catch (...) {
45843       {
45844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45845       };
45846     }
45847   }
45848
45849   jresult = result;
45850   return jresult;
45851 }
45852
45853
45854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45855   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45856   Dali::Vector3 *arg2 = 0 ;
45857
45858   arg1 = (Dali::CameraActor *)jarg1;
45859   arg2 = (Dali::Vector3 *)jarg2;
45860   if (!arg2) {
45861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45862     return ;
45863   }
45864   {
45865     try {
45866       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45867     } catch (std::out_of_range& e) {
45868       {
45869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45870       };
45871     } catch (std::exception& e) {
45872       {
45873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45874       };
45875     } catch (Dali::DaliException e) {
45876       {
45877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45878       };
45879     } catch (...) {
45880       {
45881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45882       };
45883     }
45884   }
45885
45886 }
45887
45888
45889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45890   void * jresult ;
45891   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45892   Dali::Vector3 result;
45893
45894   arg1 = (Dali::CameraActor *)jarg1;
45895   {
45896     try {
45897       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45898     } catch (std::out_of_range& e) {
45899       {
45900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45901       };
45902     } catch (std::exception& e) {
45903       {
45904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45905       };
45906     } catch (Dali::DaliException e) {
45907       {
45908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45909       };
45910     } catch (...) {
45911       {
45912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45913       };
45914     }
45915   }
45916
45917   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45918   return jresult;
45919 }
45920
45921
45922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45923   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45924   bool arg2 ;
45925
45926   arg1 = (Dali::CameraActor *)jarg1;
45927   arg2 = jarg2 ? true : false;
45928   {
45929     try {
45930       (arg1)->SetInvertYAxis(arg2);
45931     } catch (std::out_of_range& e) {
45932       {
45933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45934       };
45935     } catch (std::exception& e) {
45936       {
45937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45938       };
45939     } catch (Dali::DaliException e) {
45940       {
45941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45942       };
45943     } catch (...) {
45944       {
45945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45946       };
45947     }
45948   }
45949
45950 }
45951
45952
45953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45954   unsigned int jresult ;
45955   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45956   bool result;
45957
45958   arg1 = (Dali::CameraActor *)jarg1;
45959   {
45960     try {
45961       result = (bool)(arg1)->GetInvertYAxis();
45962     } catch (std::out_of_range& e) {
45963       {
45964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45965       };
45966     } catch (std::exception& e) {
45967       {
45968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45969       };
45970     } catch (Dali::DaliException e) {
45971       {
45972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45973       };
45974     } catch (...) {
45975       {
45976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45977       };
45978     }
45979   }
45980
45981   jresult = result;
45982   return jresult;
45983 }
45984
45985
45986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45987   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45988   Dali::Size *arg2 = 0 ;
45989
45990   arg1 = (Dali::CameraActor *)jarg1;
45991   arg2 = (Dali::Size *)jarg2;
45992   if (!arg2) {
45993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45994     return ;
45995   }
45996   {
45997     try {
45998       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45999     } catch (std::out_of_range& e) {
46000       {
46001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46002       };
46003     } catch (std::exception& e) {
46004       {
46005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46006       };
46007     } catch (Dali::DaliException e) {
46008       {
46009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46010       };
46011     } catch (...) {
46012       {
46013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46014       };
46015     }
46016   }
46017
46018 }
46019
46020
46021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
46022   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46023   Dali::Size *arg2 = 0 ;
46024
46025   arg1 = (Dali::CameraActor *)jarg1;
46026   arg2 = (Dali::Size *)jarg2;
46027   if (!arg2) {
46028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
46029     return ;
46030   }
46031   {
46032     try {
46033       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
46034     } catch (std::out_of_range& e) {
46035       {
46036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46037       };
46038     } catch (std::exception& e) {
46039       {
46040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46041       };
46042     } catch (Dali::DaliException e) {
46043       {
46044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46045       };
46046     } catch (...) {
46047       {
46048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46049       };
46050     }
46051   }
46052
46053 }
46054
46055
46056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
46057   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46058   float arg2 ;
46059   float arg3 ;
46060   float arg4 ;
46061   float arg5 ;
46062   float arg6 ;
46063   float arg7 ;
46064
46065   arg1 = (Dali::CameraActor *)jarg1;
46066   arg2 = (float)jarg2;
46067   arg3 = (float)jarg3;
46068   arg4 = (float)jarg4;
46069   arg5 = (float)jarg5;
46070   arg6 = (float)jarg6;
46071   arg7 = (float)jarg7;
46072   {
46073     try {
46074       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
46075     } catch (std::out_of_range& e) {
46076       {
46077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46078       };
46079     } catch (std::exception& e) {
46080       {
46081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46082       };
46083     } catch (Dali::DaliException e) {
46084       {
46085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46086       };
46087     } catch (...) {
46088       {
46089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46090       };
46091     }
46092   }
46093
46094 }
46095
46096
46097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
46098   void * jresult ;
46099   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46100
46101   {
46102     try {
46103       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
46104     } catch (std::out_of_range& e) {
46105       {
46106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46107       };
46108     } catch (std::exception& e) {
46109       {
46110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46111       };
46112     } catch (Dali::DaliException e) {
46113       {
46114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46115       };
46116     } catch (...) {
46117       {
46118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46119       };
46120     }
46121   }
46122
46123   jresult = (void *)result;
46124   return jresult;
46125 }
46126
46127
46128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
46129   void * jresult ;
46130   std::string arg1 ;
46131   Dali::Property::Value arg2 ;
46132   Dali::Property::Value *argp2 ;
46133   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46134
46135   if (!jarg1) {
46136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46137     return 0;
46138   }
46139   (&arg1)->assign(jarg1);
46140   argp2 = (Dali::Property::Value *)jarg2;
46141   if (!argp2) {
46142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
46143     return 0;
46144   }
46145   arg2 = *argp2;
46146   {
46147     try {
46148       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
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 = (void *)result;
46169   return jresult;
46170 }
46171
46172
46173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
46174   void * jresult ;
46175   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
46176   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46177
46178   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46179   if (!arg1) {
46180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
46181     return 0;
46182   }
46183   {
46184     try {
46185       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);
46186     } catch (std::out_of_range& e) {
46187       {
46188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46189       };
46190     } catch (std::exception& e) {
46191       {
46192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46193       };
46194     } catch (Dali::DaliException e) {
46195       {
46196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46197       };
46198     } catch (...) {
46199       {
46200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46201       };
46202     }
46203   }
46204
46205   jresult = (void *)result;
46206   return jresult;
46207 }
46208
46209
46210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
46211   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46212   std::string *arg2 = 0 ;
46213
46214   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46215   if (!jarg2) {
46216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46217     return ;
46218   }
46219   std::string arg2_str(jarg2);
46220   arg2 = &arg2_str;
46221   if (arg1) (arg1)->first = *arg2;
46222
46223   //argout typemap for const std::string&
46224
46225 }
46226
46227
46228 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
46229   char * jresult ;
46230   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46231   std::string *result = 0 ;
46232
46233   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46234   result = (std::string *) & ((arg1)->first);
46235   jresult = SWIG_csharp_string_callback(result->c_str());
46236   return jresult;
46237 }
46238
46239
46240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
46241   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46242   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
46243
46244   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46245   arg2 = (Dali::Property::Value *)jarg2;
46246   if (arg1) (arg1)->second = *arg2;
46247 }
46248
46249
46250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
46251   void * jresult ;
46252   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46253   Dali::Property::Value *result = 0 ;
46254
46255   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46256   result = (Dali::Property::Value *)& ((arg1)->second);
46257   jresult = (void *)result;
46258   return jresult;
46259 }
46260
46261
46262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
46263   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46264
46265   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46266   {
46267     try {
46268       delete arg1;
46269     } catch (std::out_of_range& e) {
46270       {
46271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46272       };
46273     } catch (std::exception& e) {
46274       {
46275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46276       };
46277     } catch (Dali::DaliException e) {
46278       {
46279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46280       };
46281     } catch (...) {
46282       {
46283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46284       };
46285     }
46286   }
46287
46288 }
46289
46290
46291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
46292   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46293
46294   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46295   {
46296     try {
46297       (arg1)->clear();
46298     } catch (std::out_of_range& e) {
46299       {
46300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46301       };
46302     } catch (std::exception& e) {
46303       {
46304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46305       };
46306     } catch (Dali::DaliException e) {
46307       {
46308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46309       };
46310     } catch (...) {
46311       {
46312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46313       };
46314     }
46315   }
46316
46317 }
46318
46319
46320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
46321   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46322   Dali::TouchPoint *arg2 = 0 ;
46323
46324   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46325   arg2 = (Dali::TouchPoint *)jarg2;
46326   if (!arg2) {
46327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46328     return ;
46329   }
46330   {
46331     try {
46332       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
46333     } catch (std::out_of_range& e) {
46334       {
46335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46336       };
46337     } catch (std::exception& e) {
46338       {
46339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46340       };
46341     } catch (Dali::DaliException e) {
46342       {
46343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46344       };
46345     } catch (...) {
46346       {
46347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46348       };
46349     }
46350   }
46351
46352 }
46353
46354
46355 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
46356   unsigned long jresult ;
46357   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46358   std::vector< Dali::TouchPoint >::size_type result;
46359
46360   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46361   {
46362     try {
46363       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
46364     } catch (std::out_of_range& e) {
46365       {
46366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46367       };
46368     } catch (std::exception& e) {
46369       {
46370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46371       };
46372     } catch (Dali::DaliException e) {
46373       {
46374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46375       };
46376     } catch (...) {
46377       {
46378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46379       };
46380     }
46381   }
46382
46383   jresult = (unsigned long)result;
46384   return jresult;
46385 }
46386
46387
46388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
46389   unsigned long jresult ;
46390   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46391   std::vector< Dali::TouchPoint >::size_type result;
46392
46393   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46394   {
46395     try {
46396       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
46397     } catch (std::out_of_range& e) {
46398       {
46399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46400       };
46401     } catch (std::exception& e) {
46402       {
46403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46404       };
46405     } catch (Dali::DaliException e) {
46406       {
46407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46408       };
46409     } catch (...) {
46410       {
46411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46412       };
46413     }
46414   }
46415
46416   jresult = (unsigned long)result;
46417   return jresult;
46418 }
46419
46420
46421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
46422   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46423   std::vector< Dali::TouchPoint >::size_type arg2 ;
46424
46425   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46426   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
46427   {
46428     try {
46429       (arg1)->reserve(arg2);
46430     } catch (std::out_of_range& e) {
46431       {
46432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46433       };
46434     } catch (std::exception& e) {
46435       {
46436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46437       };
46438     } catch (Dali::DaliException e) {
46439       {
46440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46441       };
46442     } catch (...) {
46443       {
46444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46445       };
46446     }
46447   }
46448
46449 }
46450
46451
46452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
46453   void * jresult ;
46454   std::vector< Dali::TouchPoint > *result = 0 ;
46455
46456   {
46457     try {
46458       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
46459     } catch (std::out_of_range& e) {
46460       {
46461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46462       };
46463     } catch (std::exception& e) {
46464       {
46465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46466       };
46467     } catch (Dali::DaliException e) {
46468       {
46469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46470       };
46471     } catch (...) {
46472       {
46473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46474       };
46475     }
46476   }
46477
46478   jresult = (void *)result;
46479   return jresult;
46480 }
46481
46482
46483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
46484   void * jresult ;
46485   std::vector< Dali::TouchPoint > *arg1 = 0 ;
46486   std::vector< Dali::TouchPoint > *result = 0 ;
46487
46488   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46489   if (!arg1) {
46490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46491     return 0;
46492   }
46493   {
46494     try {
46495       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
46496     } catch (std::out_of_range& e) {
46497       {
46498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46499       };
46500     } catch (std::exception& e) {
46501       {
46502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46503       };
46504     } catch (Dali::DaliException e) {
46505       {
46506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46507       };
46508     } catch (...) {
46509       {
46510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46511       };
46512     }
46513   }
46514
46515   jresult = (void *)result;
46516   return jresult;
46517 }
46518
46519
46520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46521   void * jresult ;
46522   int arg1 ;
46523   std::vector< Dali::TouchPoint > *result = 0 ;
46524
46525   arg1 = (int)jarg1;
46526   {
46527     try {
46528       try {
46529         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46530       }
46531       catch(std::out_of_range &_e) {
46532         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46533         return 0;
46534       }
46535
46536     } catch (std::out_of_range& e) {
46537       {
46538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46539       };
46540     } catch (std::exception& e) {
46541       {
46542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46543       };
46544     } catch (Dali::DaliException e) {
46545       {
46546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46547       };
46548     } catch (...) {
46549       {
46550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46551       };
46552     }
46553   }
46554
46555   jresult = (void *)result;
46556   return jresult;
46557 }
46558
46559
46560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46561   void * jresult ;
46562   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46563   int arg2 ;
46564   SwigValueWrapper< Dali::TouchPoint > result;
46565
46566   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46567   arg2 = (int)jarg2;
46568   {
46569     try {
46570       try {
46571         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46572       }
46573       catch(std::out_of_range &_e) {
46574         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46575         return 0;
46576       }
46577
46578     } catch (std::out_of_range& e) {
46579       {
46580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46581       };
46582     } catch (std::exception& e) {
46583       {
46584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46585       };
46586     } catch (Dali::DaliException e) {
46587       {
46588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46589       };
46590     } catch (...) {
46591       {
46592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46593       };
46594     }
46595   }
46596
46597   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46598   return jresult;
46599 }
46600
46601
46602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46603   void * jresult ;
46604   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46605   int arg2 ;
46606   Dali::TouchPoint *result = 0 ;
46607
46608   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46609   arg2 = (int)jarg2;
46610   {
46611     try {
46612       try {
46613         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46614       }
46615       catch(std::out_of_range &_e) {
46616         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46617         return 0;
46618       }
46619
46620     } catch (std::out_of_range& e) {
46621       {
46622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46623       };
46624     } catch (std::exception& e) {
46625       {
46626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46627       };
46628     } catch (Dali::DaliException e) {
46629       {
46630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46631       };
46632     } catch (...) {
46633       {
46634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46635       };
46636     }
46637   }
46638
46639   jresult = (void *)result;
46640   return jresult;
46641 }
46642
46643
46644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46645   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46646   int arg2 ;
46647   Dali::TouchPoint *arg3 = 0 ;
46648
46649   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46650   arg2 = (int)jarg2;
46651   arg3 = (Dali::TouchPoint *)jarg3;
46652   if (!arg3) {
46653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46654     return ;
46655   }
46656   {
46657     try {
46658       try {
46659         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46660       }
46661       catch(std::out_of_range &_e) {
46662         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46663         return ;
46664       }
46665
46666     } catch (std::out_of_range& e) {
46667       {
46668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46669       };
46670     } catch (std::exception& e) {
46671       {
46672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46673       };
46674     } catch (Dali::DaliException e) {
46675       {
46676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46677       };
46678     } catch (...) {
46679       {
46680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46681       };
46682     }
46683   }
46684
46685 }
46686
46687
46688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46689   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46690   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46691
46692   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46693   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46694   if (!arg2) {
46695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46696     return ;
46697   }
46698   {
46699     try {
46700       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46701     } catch (std::out_of_range& e) {
46702       {
46703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46704       };
46705     } catch (std::exception& e) {
46706       {
46707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46708       };
46709     } catch (Dali::DaliException e) {
46710       {
46711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46712       };
46713     } catch (...) {
46714       {
46715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46716       };
46717     }
46718   }
46719
46720 }
46721
46722
46723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46724   void * jresult ;
46725   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46726   int arg2 ;
46727   int arg3 ;
46728   std::vector< Dali::TouchPoint > *result = 0 ;
46729
46730   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46731   arg2 = (int)jarg2;
46732   arg3 = (int)jarg3;
46733   {
46734     try {
46735       try {
46736         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46737       }
46738       catch(std::out_of_range &_e) {
46739         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46740         return 0;
46741       }
46742       catch(std::invalid_argument &_e) {
46743         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46744         return 0;
46745       }
46746
46747     } catch (std::out_of_range& e) {
46748       {
46749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46750       };
46751     } catch (std::exception& e) {
46752       {
46753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46754       };
46755     } catch (Dali::DaliException e) {
46756       {
46757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46758       };
46759     } catch (...) {
46760       {
46761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46762       };
46763     }
46764   }
46765
46766   jresult = (void *)result;
46767   return jresult;
46768 }
46769
46770
46771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46772   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46773   int arg2 ;
46774   Dali::TouchPoint *arg3 = 0 ;
46775
46776   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46777   arg2 = (int)jarg2;
46778   arg3 = (Dali::TouchPoint *)jarg3;
46779   if (!arg3) {
46780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46781     return ;
46782   }
46783   {
46784     try {
46785       try {
46786         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46787       }
46788       catch(std::out_of_range &_e) {
46789         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46790         return ;
46791       }
46792
46793     } catch (std::out_of_range& e) {
46794       {
46795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46796       };
46797     } catch (std::exception& e) {
46798       {
46799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46800       };
46801     } catch (Dali::DaliException e) {
46802       {
46803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46804       };
46805     } catch (...) {
46806       {
46807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46808       };
46809     }
46810   }
46811
46812 }
46813
46814
46815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46816   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46817   int arg2 ;
46818   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46819
46820   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46821   arg2 = (int)jarg2;
46822   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46823   if (!arg3) {
46824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46825     return ;
46826   }
46827   {
46828     try {
46829       try {
46830         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46831       }
46832       catch(std::out_of_range &_e) {
46833         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46834         return ;
46835       }
46836
46837     } catch (std::out_of_range& e) {
46838       {
46839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46840       };
46841     } catch (std::exception& e) {
46842       {
46843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46844       };
46845     } catch (Dali::DaliException e) {
46846       {
46847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46848       };
46849     } catch (...) {
46850       {
46851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46852       };
46853     }
46854   }
46855
46856 }
46857
46858
46859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46860   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46861   int arg2 ;
46862
46863   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46864   arg2 = (int)jarg2;
46865   {
46866     try {
46867       try {
46868         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46869       }
46870       catch(std::out_of_range &_e) {
46871         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46872         return ;
46873       }
46874
46875     } catch (std::out_of_range& e) {
46876       {
46877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46878       };
46879     } catch (std::exception& e) {
46880       {
46881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46882       };
46883     } catch (Dali::DaliException e) {
46884       {
46885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46886       };
46887     } catch (...) {
46888       {
46889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46890       };
46891     }
46892   }
46893
46894 }
46895
46896
46897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46898   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46899   int arg2 ;
46900   int arg3 ;
46901
46902   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46903   arg2 = (int)jarg2;
46904   arg3 = (int)jarg3;
46905   {
46906     try {
46907       try {
46908         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46909       }
46910       catch(std::out_of_range &_e) {
46911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46912         return ;
46913       }
46914       catch(std::invalid_argument &_e) {
46915         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46916         return ;
46917       }
46918
46919     } catch (std::out_of_range& e) {
46920       {
46921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46922       };
46923     } catch (std::exception& e) {
46924       {
46925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46926       };
46927     } catch (Dali::DaliException e) {
46928       {
46929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46930       };
46931     } catch (...) {
46932       {
46933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46934       };
46935     }
46936   }
46937
46938 }
46939
46940
46941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46942   void * jresult ;
46943   Dali::TouchPoint *arg1 = 0 ;
46944   int arg2 ;
46945   std::vector< Dali::TouchPoint > *result = 0 ;
46946
46947   arg1 = (Dali::TouchPoint *)jarg1;
46948   if (!arg1) {
46949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46950     return 0;
46951   }
46952   arg2 = (int)jarg2;
46953   {
46954     try {
46955       try {
46956         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46957       }
46958       catch(std::out_of_range &_e) {
46959         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46960         return 0;
46961       }
46962
46963     } catch (std::out_of_range& e) {
46964       {
46965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46966       };
46967     } catch (std::exception& e) {
46968       {
46969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46970       };
46971     } catch (Dali::DaliException e) {
46972       {
46973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46974       };
46975     } catch (...) {
46976       {
46977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46978       };
46979     }
46980   }
46981
46982   jresult = (void *)result;
46983   return jresult;
46984 }
46985
46986
46987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46988   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46989
46990   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46991   {
46992     try {
46993       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46994     } catch (std::out_of_range& e) {
46995       {
46996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46997       };
46998     } catch (std::exception& e) {
46999       {
47000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47001       };
47002     } catch (Dali::DaliException e) {
47003       {
47004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47005       };
47006     } catch (...) {
47007       {
47008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47009       };
47010     }
47011   }
47012
47013 }
47014
47015
47016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
47017   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47018   int arg2 ;
47019   int arg3 ;
47020
47021   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47022   arg2 = (int)jarg2;
47023   arg3 = (int)jarg3;
47024   {
47025     try {
47026       try {
47027         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
47028       }
47029       catch(std::out_of_range &_e) {
47030         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47031         return ;
47032       }
47033       catch(std::invalid_argument &_e) {
47034         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
47035         return ;
47036       }
47037
47038     } catch (std::out_of_range& e) {
47039       {
47040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47041       };
47042     } catch (std::exception& e) {
47043       {
47044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47045       };
47046     } catch (Dali::DaliException e) {
47047       {
47048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47049       };
47050     } catch (...) {
47051       {
47052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47053       };
47054     }
47055   }
47056
47057 }
47058
47059
47060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
47061   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47062   int arg2 ;
47063   std::vector< Dali::TouchPoint > *arg3 = 0 ;
47064
47065   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47066   arg2 = (int)jarg2;
47067   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
47068   if (!arg3) {
47069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
47070     return ;
47071   }
47072   {
47073     try {
47074       try {
47075         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
47076       }
47077       catch(std::out_of_range &_e) {
47078         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47079         return ;
47080       }
47081
47082     } catch (std::out_of_range& e) {
47083       {
47084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47085       };
47086     } catch (std::exception& e) {
47087       {
47088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47089       };
47090     } catch (Dali::DaliException e) {
47091       {
47092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47093       };
47094     } catch (...) {
47095       {
47096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47097       };
47098     }
47099   }
47100
47101 }
47102
47103
47104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
47105   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47106
47107   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47108   {
47109     try {
47110       delete arg1;
47111     } catch (std::out_of_range& e) {
47112       {
47113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47114       };
47115     } catch (std::exception& e) {
47116       {
47117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47118       };
47119     } catch (Dali::DaliException e) {
47120       {
47121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47122       };
47123     } catch (...) {
47124       {
47125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47126       };
47127     }
47128   }
47129
47130 }
47131
47132
47133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
47134   void * jresult ;
47135   Dali::Rect< int > *result = 0 ;
47136
47137   {
47138     try {
47139       result = (Dali::Rect< int > *)new Dali::Rect< int >();
47140     } catch (std::out_of_range& e) {
47141       {
47142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47143       };
47144     } catch (std::exception& e) {
47145       {
47146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47147       };
47148     } catch (Dali::DaliException e) {
47149       {
47150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47151       };
47152     } catch (...) {
47153       {
47154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47155       };
47156     }
47157   }
47158
47159   jresult = (void *)result;
47160   return jresult;
47161 }
47162
47163
47164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
47165   void * jresult ;
47166   int arg1 ;
47167   int arg2 ;
47168   int arg3 ;
47169   int arg4 ;
47170   Dali::Rect< int > *result = 0 ;
47171
47172   arg1 = (int)jarg1;
47173   arg2 = (int)jarg2;
47174   arg3 = (int)jarg3;
47175   arg4 = (int)jarg4;
47176   {
47177     try {
47178       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
47179     } catch (std::out_of_range& e) {
47180       {
47181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47182       };
47183     } catch (std::exception& e) {
47184       {
47185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47186       };
47187     } catch (Dali::DaliException e) {
47188       {
47189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47190       };
47191     } catch (...) {
47192       {
47193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47194       };
47195     }
47196   }
47197
47198   jresult = (void *)result;
47199   return jresult;
47200 }
47201
47202
47203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
47204   void * jresult ;
47205   Dali::Rect< int > *arg1 = 0 ;
47206   Dali::Rect< int > *result = 0 ;
47207
47208   arg1 = (Dali::Rect< int > *)jarg1;
47209   if (!arg1) {
47210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47211     return 0;
47212   }
47213   {
47214     try {
47215       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
47216     } catch (std::out_of_range& e) {
47217       {
47218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47219       };
47220     } catch (std::exception& e) {
47221       {
47222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47223       };
47224     } catch (Dali::DaliException e) {
47225       {
47226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47227       };
47228     } catch (...) {
47229       {
47230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47231       };
47232     }
47233   }
47234
47235   jresult = (void *)result;
47236   return jresult;
47237 }
47238
47239
47240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
47241   void * jresult ;
47242   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47243   Dali::Rect< int > *arg2 = 0 ;
47244   Dali::Rect< int > *result = 0 ;
47245
47246   arg1 = (Dali::Rect< int > *)jarg1;
47247   arg2 = (Dali::Rect< int > *)jarg2;
47248   if (!arg2) {
47249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47250     return 0;
47251   }
47252   {
47253     try {
47254       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
47255     } catch (std::out_of_range& e) {
47256       {
47257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47258       };
47259     } catch (std::exception& e) {
47260       {
47261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47262       };
47263     } catch (Dali::DaliException e) {
47264       {
47265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47266       };
47267     } catch (...) {
47268       {
47269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47270       };
47271     }
47272   }
47273
47274   jresult = (void *)result;
47275   return jresult;
47276 }
47277
47278
47279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
47280   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47281   int arg2 ;
47282   int arg3 ;
47283   int arg4 ;
47284   int arg5 ;
47285
47286   arg1 = (Dali::Rect< int > *)jarg1;
47287   arg2 = (int)jarg2;
47288   arg3 = (int)jarg3;
47289   arg4 = (int)jarg4;
47290   arg5 = (int)jarg5;
47291   {
47292     try {
47293       (arg1)->Set(arg2,arg3,arg4,arg5);
47294     } catch (std::out_of_range& e) {
47295       {
47296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47297       };
47298     } catch (std::exception& e) {
47299       {
47300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47301       };
47302     } catch (Dali::DaliException e) {
47303       {
47304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47305       };
47306     } catch (...) {
47307       {
47308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47309       };
47310     }
47311   }
47312
47313 }
47314
47315
47316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
47317   unsigned int jresult ;
47318   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47319   bool result;
47320
47321   arg1 = (Dali::Rect< int > *)jarg1;
47322   {
47323     try {
47324       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
47325     } catch (std::out_of_range& e) {
47326       {
47327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47328       };
47329     } catch (std::exception& e) {
47330       {
47331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47332       };
47333     } catch (Dali::DaliException e) {
47334       {
47335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47336       };
47337     } catch (...) {
47338       {
47339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47340       };
47341     }
47342   }
47343
47344   jresult = result;
47345   return jresult;
47346 }
47347
47348
47349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
47350   int jresult ;
47351   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47352   int result;
47353
47354   arg1 = (Dali::Rect< int > *)jarg1;
47355   {
47356     try {
47357       result = (int)((Dali::Rect< int > const *)arg1)->Left();
47358     } catch (std::out_of_range& e) {
47359       {
47360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47361       };
47362     } catch (std::exception& e) {
47363       {
47364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47365       };
47366     } catch (Dali::DaliException e) {
47367       {
47368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47369       };
47370     } catch (...) {
47371       {
47372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47373       };
47374     }
47375   }
47376
47377   jresult = result;
47378   return jresult;
47379 }
47380
47381
47382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
47383   int jresult ;
47384   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47385   int result;
47386
47387   arg1 = (Dali::Rect< int > *)jarg1;
47388   {
47389     try {
47390       result = (int)((Dali::Rect< int > const *)arg1)->Right();
47391     } catch (std::out_of_range& e) {
47392       {
47393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47394       };
47395     } catch (std::exception& e) {
47396       {
47397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47398       };
47399     } catch (Dali::DaliException e) {
47400       {
47401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47402       };
47403     } catch (...) {
47404       {
47405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47406       };
47407     }
47408   }
47409
47410   jresult = result;
47411   return jresult;
47412 }
47413
47414
47415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
47416   int jresult ;
47417   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47418   int result;
47419
47420   arg1 = (Dali::Rect< int > *)jarg1;
47421   {
47422     try {
47423       result = (int)((Dali::Rect< int > const *)arg1)->Top();
47424     } catch (std::out_of_range& e) {
47425       {
47426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47427       };
47428     } catch (std::exception& e) {
47429       {
47430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47431       };
47432     } catch (Dali::DaliException e) {
47433       {
47434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47435       };
47436     } catch (...) {
47437       {
47438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47439       };
47440     }
47441   }
47442
47443   jresult = result;
47444   return jresult;
47445 }
47446
47447
47448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
47449   int jresult ;
47450   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47451   int result;
47452
47453   arg1 = (Dali::Rect< int > *)jarg1;
47454   {
47455     try {
47456       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
47457     } catch (std::out_of_range& e) {
47458       {
47459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47460       };
47461     } catch (std::exception& e) {
47462       {
47463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47464       };
47465     } catch (Dali::DaliException e) {
47466       {
47467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47468       };
47469     } catch (...) {
47470       {
47471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47472       };
47473     }
47474   }
47475
47476   jresult = result;
47477   return jresult;
47478 }
47479
47480
47481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
47482   int jresult ;
47483   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47484   int result;
47485
47486   arg1 = (Dali::Rect< int > *)jarg1;
47487   {
47488     try {
47489       result = (int)((Dali::Rect< int > const *)arg1)->Area();
47490     } catch (std::out_of_range& e) {
47491       {
47492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47493       };
47494     } catch (std::exception& e) {
47495       {
47496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47497       };
47498     } catch (Dali::DaliException e) {
47499       {
47500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47501       };
47502     } catch (...) {
47503       {
47504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47505       };
47506     }
47507   }
47508
47509   jresult = result;
47510   return jresult;
47511 }
47512
47513
47514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
47515   unsigned int jresult ;
47516   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47517   Dali::Rect< int > *arg2 = 0 ;
47518   bool result;
47519
47520   arg1 = (Dali::Rect< int > *)jarg1;
47521   arg2 = (Dali::Rect< int > *)jarg2;
47522   if (!arg2) {
47523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47524     return 0;
47525   }
47526   {
47527     try {
47528       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47529     } catch (std::out_of_range& e) {
47530       {
47531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47532       };
47533     } catch (std::exception& e) {
47534       {
47535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47536       };
47537     } catch (Dali::DaliException e) {
47538       {
47539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47540       };
47541     } catch (...) {
47542       {
47543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47544       };
47545     }
47546   }
47547
47548   jresult = result;
47549   return jresult;
47550 }
47551
47552
47553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47554   unsigned int jresult ;
47555   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47556   Dali::Rect< int > *arg2 = 0 ;
47557   bool result;
47558
47559   arg1 = (Dali::Rect< int > *)jarg1;
47560   arg2 = (Dali::Rect< int > *)jarg2;
47561   if (!arg2) {
47562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47563     return 0;
47564   }
47565   {
47566     try {
47567       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47568     } catch (std::out_of_range& e) {
47569       {
47570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47571       };
47572     } catch (std::exception& e) {
47573       {
47574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47575       };
47576     } catch (Dali::DaliException e) {
47577       {
47578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47579       };
47580     } catch (...) {
47581       {
47582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47583       };
47584     }
47585   }
47586
47587   jresult = result;
47588   return jresult;
47589 }
47590
47591
47592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47593   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47594   int arg2 ;
47595
47596   arg1 = (Dali::Rect< int > *)jarg1;
47597   arg2 = (int)jarg2;
47598   if (arg1) (arg1)->x = arg2;
47599 }
47600
47601
47602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47603   int jresult ;
47604   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47605   int result;
47606
47607   arg1 = (Dali::Rect< int > *)jarg1;
47608   result = (int) ((arg1)->x);
47609   jresult = result;
47610   return jresult;
47611 }
47612
47613
47614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47615   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47616   int arg2 ;
47617
47618   arg1 = (Dali::Rect< int > *)jarg1;
47619   arg2 = (int)jarg2;
47620   if (arg1) (arg1)->left = arg2;
47621 }
47622
47623
47624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47625   int jresult ;
47626   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47627   int result;
47628
47629   arg1 = (Dali::Rect< int > *)jarg1;
47630   result = (int) ((arg1)->left);
47631   jresult = result;
47632   return jresult;
47633 }
47634
47635
47636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47637   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47638   int arg2 ;
47639
47640   arg1 = (Dali::Rect< int > *)jarg1;
47641   arg2 = (int)jarg2;
47642   if (arg1) (arg1)->y = arg2;
47643 }
47644
47645
47646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47647   int jresult ;
47648   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47649   int result;
47650
47651   arg1 = (Dali::Rect< int > *)jarg1;
47652   result = (int) ((arg1)->y);
47653   jresult = result;
47654   return jresult;
47655 }
47656
47657
47658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47659   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47660   int arg2 ;
47661
47662   arg1 = (Dali::Rect< int > *)jarg1;
47663   arg2 = (int)jarg2;
47664   if (arg1) (arg1)->right = arg2;
47665 }
47666
47667
47668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47669   int jresult ;
47670   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47671   int result;
47672
47673   arg1 = (Dali::Rect< int > *)jarg1;
47674   result = (int) ((arg1)->right);
47675   jresult = result;
47676   return jresult;
47677 }
47678
47679
47680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47681   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47682   int arg2 ;
47683
47684   arg1 = (Dali::Rect< int > *)jarg1;
47685   arg2 = (int)jarg2;
47686   if (arg1) (arg1)->width = arg2;
47687 }
47688
47689
47690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47691   int jresult ;
47692   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47693   int result;
47694
47695   arg1 = (Dali::Rect< int > *)jarg1;
47696   result = (int) ((arg1)->width);
47697   jresult = result;
47698   return jresult;
47699 }
47700
47701
47702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47703   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47704   int arg2 ;
47705
47706   arg1 = (Dali::Rect< int > *)jarg1;
47707   arg2 = (int)jarg2;
47708   if (arg1) (arg1)->bottom = arg2;
47709 }
47710
47711
47712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47713   int jresult ;
47714   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47715   int result;
47716
47717   arg1 = (Dali::Rect< int > *)jarg1;
47718   result = (int) ((arg1)->bottom);
47719   jresult = result;
47720   return jresult;
47721 }
47722
47723
47724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47725   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47726   int arg2 ;
47727
47728   arg1 = (Dali::Rect< int > *)jarg1;
47729   arg2 = (int)jarg2;
47730   if (arg1) (arg1)->height = arg2;
47731 }
47732
47733
47734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47735   int jresult ;
47736   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47737   int result;
47738
47739   arg1 = (Dali::Rect< int > *)jarg1;
47740   result = (int) ((arg1)->height);
47741   jresult = result;
47742   return jresult;
47743 }
47744
47745
47746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47747   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47748   int arg2 ;
47749
47750   arg1 = (Dali::Rect< int > *)jarg1;
47751   arg2 = (int)jarg2;
47752   if (arg1) (arg1)->top = arg2;
47753 }
47754
47755
47756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47757   int jresult ;
47758   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47759   int result;
47760
47761   arg1 = (Dali::Rect< int > *)jarg1;
47762   result = (int) ((arg1)->top);
47763   jresult = result;
47764   return jresult;
47765 }
47766
47767
47768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47769   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47770
47771   arg1 = (Dali::Rect< int > *)jarg1;
47772   {
47773     try {
47774       delete arg1;
47775     } catch (std::out_of_range& e) {
47776       {
47777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47778       };
47779     } catch (std::exception& e) {
47780       {
47781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47782       };
47783     } catch (Dali::DaliException e) {
47784       {
47785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47786       };
47787     } catch (...) {
47788       {
47789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47790       };
47791     }
47792   }
47793
47794 }
47795
47796
47797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47798   void * jresult ;
47799   Dali::Rect< float > *result = 0 ;
47800
47801   {
47802     try {
47803       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47804     } catch (std::out_of_range& e) {
47805       {
47806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47807       };
47808     } catch (std::exception& e) {
47809       {
47810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47811       };
47812     } catch (Dali::DaliException e) {
47813       {
47814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47815       };
47816     } catch (...) {
47817       {
47818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47819       };
47820     }
47821   }
47822
47823   jresult = (void *)result;
47824   return jresult;
47825 }
47826
47827
47828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47829   void * jresult ;
47830   float arg1 ;
47831   float arg2 ;
47832   float arg3 ;
47833   float arg4 ;
47834   Dali::Rect< float > *result = 0 ;
47835
47836   arg1 = (float)jarg1;
47837   arg2 = (float)jarg2;
47838   arg3 = (float)jarg4;
47839   arg4 = (float)jarg3;
47840   {
47841     try {
47842       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47843     } catch (std::out_of_range& e) {
47844       {
47845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47846       };
47847     } catch (std::exception& e) {
47848       {
47849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47850       };
47851     } catch (Dali::DaliException e) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47854       };
47855     } catch (...) {
47856       {
47857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47858       };
47859     }
47860   }
47861
47862   jresult = (void *)result;
47863   return jresult;
47864 }
47865
47866
47867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47868   void * jresult ;
47869   Dali::Rect< float > *arg1 = 0 ;
47870   Dali::Rect< float > *result = 0 ;
47871
47872   arg1 = (Dali::Rect< float > *)jarg1;
47873   if (!arg1) {
47874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47875     return 0;
47876   }
47877   {
47878     try {
47879       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47880     } catch (std::out_of_range& e) {
47881       {
47882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47883       };
47884     } catch (std::exception& e) {
47885       {
47886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47887       };
47888     } catch (Dali::DaliException e) {
47889       {
47890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47891       };
47892     } catch (...) {
47893       {
47894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47895       };
47896     }
47897   }
47898
47899   jresult = (void *)result;
47900   return jresult;
47901 }
47902
47903
47904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47905   void * jresult ;
47906   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47907   Dali::Rect< float > *arg2 = 0 ;
47908   Dali::Rect< float > *result = 0 ;
47909
47910   arg1 = (Dali::Rect< float > *)jarg1;
47911   arg2 = (Dali::Rect< float > *)jarg2;
47912   if (!arg2) {
47913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47914     return 0;
47915   }
47916   {
47917     try {
47918       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47919     } catch (std::out_of_range& e) {
47920       {
47921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47922       };
47923     } catch (std::exception& e) {
47924       {
47925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47926       };
47927     } catch (Dali::DaliException e) {
47928       {
47929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47930       };
47931     } catch (...) {
47932       {
47933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47934       };
47935     }
47936   }
47937
47938   jresult = (void *)result;
47939   return jresult;
47940 }
47941
47942
47943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47944   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47945   float arg2 ;
47946   float arg3 ;
47947   float arg4 ;
47948   float arg5 ;
47949
47950   arg1 = (Dali::Rect< float > *)jarg1;
47951   arg2 = (float)jarg2;
47952   arg3 = (float)jarg3;
47953   arg4 = (float)jarg5;
47954   arg5 = (float)jarg4;
47955   {
47956     try {
47957       (arg1)->Set(arg2,arg3,arg4,arg5);
47958     } catch (std::out_of_range& e) {
47959       {
47960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47961       };
47962     } catch (std::exception& e) {
47963       {
47964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47965       };
47966     } catch (Dali::DaliException e) {
47967       {
47968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47969       };
47970     } catch (...) {
47971       {
47972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47973       };
47974     }
47975   }
47976
47977 }
47978
47979
47980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47981   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47982   float arg2 ;
47983
47984   arg1 = (Dali::Rect< float > *)jarg1;
47985   arg2 = (float)jarg2;
47986   if (arg1) (arg1)->left = arg2;
47987 }
47988
47989
47990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47991   float jresult ;
47992   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47993   float result;
47994
47995   arg1 = (Dali::Rect< float > *)jarg1;
47996   result = (float) ((arg1)->left);
47997   jresult = result;
47998   return jresult;
47999 }
48000
48001
48002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
48003   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48004   float arg2 ;
48005
48006   arg1 = (Dali::Rect< float > *)jarg1;
48007   arg2 = (float)jarg2;
48008   if (arg1) (arg1)->left = arg2;
48009 }
48010
48011
48012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
48013   float jresult ;
48014   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48015   float result;
48016
48017   arg1 = (Dali::Rect< float > *)jarg1;
48018   result = (float) ((arg1)->left);
48019   jresult = result;
48020   return jresult;
48021 }
48022
48023
48024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
48025   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48026   float arg2 ;
48027
48028   arg1 = (Dali::Rect< float > *)jarg1;
48029   arg2 = (float)jarg2;
48030   if (arg1) (arg1)->right = arg2;
48031 }
48032
48033
48034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
48035   float jresult ;
48036   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48037   float result;
48038
48039   arg1 = (Dali::Rect< float > *)jarg1;
48040   result = (float) ((arg1)->right);
48041   jresult = result;
48042   return jresult;
48043 }
48044
48045
48046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
48047   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48048   float arg2 ;
48049
48050   arg1 = (Dali::Rect< float > *)jarg1;
48051   arg2 = (float)jarg2;
48052   if (arg1) (arg1)->right = arg2;
48053 }
48054
48055
48056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
48057   float jresult ;
48058   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48059   float result;
48060
48061   arg1 = (Dali::Rect< float > *)jarg1;
48062   result = (float) ((arg1)->right);
48063   jresult = result;
48064   return jresult;
48065 }
48066
48067
48068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
48069   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48070   float arg2 ;
48071
48072   arg1 = (Dali::Rect< float > *)jarg1;
48073   arg2 = (float)jarg2;
48074   if (arg1) (arg1)->bottom = arg2;
48075 }
48076
48077
48078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
48079   float jresult ;
48080   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48081   float result;
48082
48083   arg1 = (Dali::Rect< float > *)jarg1;
48084   result = (float) ((arg1)->bottom);
48085   jresult = result;
48086   return jresult;
48087 }
48088
48089
48090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
48091   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48092   float arg2 ;
48093
48094   arg1 = (Dali::Rect< float > *)jarg1;
48095   arg2 = (float)jarg2;
48096   if (arg1) (arg1)->top = arg2;
48097 }
48098
48099
48100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
48101   float jresult ;
48102   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48103   float result;
48104
48105   arg1 = (Dali::Rect< float > *)jarg1;
48106   result = (float) ((arg1)->top);
48107   jresult = result;
48108   return jresult;
48109 }
48110
48111
48112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
48113   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48114
48115   arg1 = (Dali::Rect< float > *)jarg1;
48116   {
48117     try {
48118       delete arg1;
48119     } catch (std::out_of_range& e) {
48120       {
48121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48122       };
48123     } catch (std::exception& e) {
48124       {
48125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48126       };
48127     } catch (Dali::DaliException e) {
48128       {
48129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48130       };
48131     } catch (...) {
48132       {
48133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48134       };
48135     }
48136   }
48137
48138 }
48139
48140
48141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
48142   int jresult ;
48143   int result;
48144
48145   result = (int)Dali::Vector< int >::BaseType;
48146   jresult = (int)result;
48147   return jresult;
48148 }
48149
48150
48151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
48152   void * jresult ;
48153   Dali::Vector< int > *result = 0 ;
48154
48155   {
48156     try {
48157       result = (Dali::Vector< int > *)new Dali::Vector< int >();
48158     } catch (std::out_of_range& e) {
48159       {
48160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48161       };
48162     } catch (std::exception& e) {
48163       {
48164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48165       };
48166     } catch (Dali::DaliException e) {
48167       {
48168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48169       };
48170     } catch (...) {
48171       {
48172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48173       };
48174     }
48175   }
48176
48177   jresult = (void *)result;
48178   return jresult;
48179 }
48180
48181
48182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
48183   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48184
48185   arg1 = (Dali::Vector< int > *)jarg1;
48186   {
48187     try {
48188       delete arg1;
48189     } catch (std::out_of_range& e) {
48190       {
48191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48192       };
48193     } catch (std::exception& e) {
48194       {
48195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48196       };
48197     } catch (Dali::DaliException e) {
48198       {
48199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48200       };
48201     } catch (...) {
48202       {
48203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48204       };
48205     }
48206   }
48207
48208 }
48209
48210
48211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
48212   void * jresult ;
48213   Dali::Vector< int > *arg1 = 0 ;
48214   Dali::Vector< int > *result = 0 ;
48215
48216   arg1 = (Dali::Vector< int > *)jarg1;
48217   if (!arg1) {
48218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48219     return 0;
48220   }
48221   {
48222     try {
48223       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
48224     } catch (std::out_of_range& e) {
48225       {
48226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48227       };
48228     } catch (std::exception& e) {
48229       {
48230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48231       };
48232     } catch (Dali::DaliException e) {
48233       {
48234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48235       };
48236     } catch (...) {
48237       {
48238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48239       };
48240     }
48241   }
48242
48243   jresult = (void *)result;
48244   return jresult;
48245 }
48246
48247
48248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
48249   void * jresult ;
48250   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48251   Dali::Vector< int > *arg2 = 0 ;
48252   Dali::Vector< int > *result = 0 ;
48253
48254   arg1 = (Dali::Vector< int > *)jarg1;
48255   arg2 = (Dali::Vector< int > *)jarg2;
48256   if (!arg2) {
48257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48258     return 0;
48259   }
48260   {
48261     try {
48262       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
48263     } catch (std::out_of_range& e) {
48264       {
48265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48266       };
48267     } catch (std::exception& e) {
48268       {
48269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48270       };
48271     } catch (Dali::DaliException e) {
48272       {
48273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48274       };
48275     } catch (...) {
48276       {
48277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48278       };
48279     }
48280   }
48281
48282   jresult = (void *)result;
48283   return jresult;
48284 }
48285
48286
48287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
48288   void * jresult ;
48289   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48290   Dali::Vector< int >::Iterator result;
48291
48292   arg1 = (Dali::Vector< int > *)jarg1;
48293   {
48294     try {
48295       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
48296     } catch (std::out_of_range& e) {
48297       {
48298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48299       };
48300     } catch (std::exception& e) {
48301       {
48302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48303       };
48304     } catch (Dali::DaliException e) {
48305       {
48306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48307       };
48308     } catch (...) {
48309       {
48310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48311       };
48312     }
48313   }
48314
48315   jresult = (void *)result;
48316   return jresult;
48317 }
48318
48319
48320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
48321   void * jresult ;
48322   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48323   Dali::Vector< int >::Iterator result;
48324
48325   arg1 = (Dali::Vector< int > *)jarg1;
48326   {
48327     try {
48328       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
48329     } catch (std::out_of_range& e) {
48330       {
48331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48332       };
48333     } catch (std::exception& e) {
48334       {
48335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48336       };
48337     } catch (Dali::DaliException e) {
48338       {
48339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48340       };
48341     } catch (...) {
48342       {
48343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48344       };
48345     }
48346   }
48347
48348   jresult = (void *)result;
48349   return jresult;
48350 }
48351
48352
48353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48354   void * jresult ;
48355   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48356   Dali::Vector< int >::SizeType arg2 ;
48357   Dali::Vector< int >::ItemType *result = 0 ;
48358
48359   arg1 = (Dali::Vector< int > *)jarg1;
48360   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48361   {
48362     try {
48363       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
48364     } catch (std::out_of_range& e) {
48365       {
48366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48367       };
48368     } catch (std::exception& e) {
48369       {
48370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48371       };
48372     } catch (Dali::DaliException e) {
48373       {
48374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48375       };
48376     } catch (...) {
48377       {
48378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48379       };
48380     }
48381   }
48382
48383   jresult = (void *)result;
48384   return jresult;
48385 }
48386
48387
48388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
48389   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48390   Dali::Vector< int >::ItemType *arg2 = 0 ;
48391   Dali::Vector< int >::ItemType temp2 ;
48392
48393   arg1 = (Dali::Vector< int > *)jarg1;
48394   temp2 = (Dali::Vector< int >::ItemType)jarg2;
48395   arg2 = &temp2;
48396   {
48397     try {
48398       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
48399     } catch (std::out_of_range& e) {
48400       {
48401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48402       };
48403     } catch (std::exception& e) {
48404       {
48405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48406       };
48407     } catch (Dali::DaliException e) {
48408       {
48409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48410       };
48411     } catch (...) {
48412       {
48413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48414       };
48415     }
48416   }
48417
48418 }
48419
48420
48421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
48422   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48423   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48424   Dali::Vector< int >::ItemType *arg3 = 0 ;
48425   Dali::Vector< int >::ItemType temp3 ;
48426
48427   arg1 = (Dali::Vector< int > *)jarg1;
48428   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48429   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48430   arg3 = &temp3;
48431   {
48432     try {
48433       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48434     } catch (std::out_of_range& e) {
48435       {
48436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48437       };
48438     } catch (std::exception& e) {
48439       {
48440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48441       };
48442     } catch (Dali::DaliException e) {
48443       {
48444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48445       };
48446     } catch (...) {
48447       {
48448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48449       };
48450     }
48451   }
48452
48453 }
48454
48455
48456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48457   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48458   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48459   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48460   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
48461
48462   arg1 = (Dali::Vector< int > *)jarg1;
48463   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48464   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48465   arg4 = (Dali::Vector< int >::Iterator)jarg4;
48466   {
48467     try {
48468       (arg1)->Insert(arg2,arg3,arg4);
48469     } catch (std::out_of_range& e) {
48470       {
48471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48472       };
48473     } catch (std::exception& e) {
48474       {
48475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48476       };
48477     } catch (Dali::DaliException e) {
48478       {
48479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48480       };
48481     } catch (...) {
48482       {
48483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48484       };
48485     }
48486   }
48487
48488 }
48489
48490
48491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
48492   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48493   Dali::Vector< int >::SizeType arg2 ;
48494
48495   arg1 = (Dali::Vector< int > *)jarg1;
48496   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48497   {
48498     try {
48499       (arg1)->Reserve(arg2);
48500     } catch (std::out_of_range& e) {
48501       {
48502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48503       };
48504     } catch (std::exception& e) {
48505       {
48506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48507       };
48508     } catch (Dali::DaliException e) {
48509       {
48510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48511       };
48512     } catch (...) {
48513       {
48514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48515       };
48516     }
48517   }
48518
48519 }
48520
48521
48522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48523   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48524   Dali::Vector< int >::SizeType arg2 ;
48525
48526   arg1 = (Dali::Vector< int > *)jarg1;
48527   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48528   {
48529     try {
48530       (arg1)->Resize(arg2);
48531     } catch (std::out_of_range& e) {
48532       {
48533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48534       };
48535     } catch (std::exception& e) {
48536       {
48537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48538       };
48539     } catch (Dali::DaliException e) {
48540       {
48541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48542       };
48543     } catch (...) {
48544       {
48545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48546       };
48547     }
48548   }
48549
48550 }
48551
48552
48553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48554   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48555   Dali::Vector< int >::SizeType arg2 ;
48556   Dali::Vector< int >::ItemType *arg3 = 0 ;
48557   Dali::Vector< int >::ItemType temp3 ;
48558
48559   arg1 = (Dali::Vector< int > *)jarg1;
48560   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48561   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48562   arg3 = &temp3;
48563   {
48564     try {
48565       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48566     } catch (std::out_of_range& e) {
48567       {
48568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48569       };
48570     } catch (std::exception& e) {
48571       {
48572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48573       };
48574     } catch (Dali::DaliException e) {
48575       {
48576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48577       };
48578     } catch (...) {
48579       {
48580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48581       };
48582     }
48583   }
48584
48585 }
48586
48587
48588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48589   void * jresult ;
48590   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48591   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48592   Dali::Vector< int >::Iterator result;
48593
48594   arg1 = (Dali::Vector< int > *)jarg1;
48595   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48596   {
48597     try {
48598       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48599     } catch (std::out_of_range& e) {
48600       {
48601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48602       };
48603     } catch (std::exception& e) {
48604       {
48605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48606       };
48607     } catch (Dali::DaliException e) {
48608       {
48609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48610       };
48611     } catch (...) {
48612       {
48613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48614       };
48615     }
48616   }
48617
48618   jresult = (void *)result;
48619   return jresult;
48620 }
48621
48622
48623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48624   void * jresult ;
48625   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48626   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48627   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48628   Dali::Vector< int >::Iterator result;
48629
48630   arg1 = (Dali::Vector< int > *)jarg1;
48631   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48632   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48633   {
48634     try {
48635       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48636     } catch (std::out_of_range& e) {
48637       {
48638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48639       };
48640     } catch (std::exception& e) {
48641       {
48642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48643       };
48644     } catch (Dali::DaliException e) {
48645       {
48646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48647       };
48648     } catch (...) {
48649       {
48650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48651       };
48652     }
48653   }
48654
48655   jresult = (void *)result;
48656   return jresult;
48657 }
48658
48659
48660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48661   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48662   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48663
48664   arg1 = (Dali::Vector< int > *)jarg1;
48665   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48666   {
48667     try {
48668       (arg1)->Remove(arg2);
48669     } catch (std::out_of_range& e) {
48670       {
48671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48672       };
48673     } catch (std::exception& e) {
48674       {
48675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48676       };
48677     } catch (Dali::DaliException e) {
48678       {
48679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48680       };
48681     } catch (...) {
48682       {
48683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48684       };
48685     }
48686   }
48687
48688 }
48689
48690
48691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48692   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48693   Dali::Vector< int > *arg2 = 0 ;
48694
48695   arg1 = (Dali::Vector< int > *)jarg1;
48696   arg2 = (Dali::Vector< int > *)jarg2;
48697   if (!arg2) {
48698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48699     return ;
48700   }
48701   {
48702     try {
48703       (arg1)->Swap(*arg2);
48704     } catch (std::out_of_range& e) {
48705       {
48706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48707       };
48708     } catch (std::exception& e) {
48709       {
48710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48711       };
48712     } catch (Dali::DaliException e) {
48713       {
48714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48715       };
48716     } catch (...) {
48717       {
48718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48719       };
48720     }
48721   }
48722
48723 }
48724
48725
48726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48727   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48728
48729   arg1 = (Dali::Vector< int > *)jarg1;
48730   {
48731     try {
48732       (arg1)->Clear();
48733     } catch (std::out_of_range& e) {
48734       {
48735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48736       };
48737     } catch (std::exception& e) {
48738       {
48739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48740       };
48741     } catch (Dali::DaliException e) {
48742       {
48743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48744       };
48745     } catch (...) {
48746       {
48747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48748       };
48749     }
48750   }
48751
48752 }
48753
48754
48755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48756   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48757
48758   arg1 = (Dali::Vector< int > *)jarg1;
48759   {
48760     try {
48761       (arg1)->Release();
48762     } catch (std::out_of_range& e) {
48763       {
48764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48765       };
48766     } catch (std::exception& e) {
48767       {
48768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48769       };
48770     } catch (Dali::DaliException e) {
48771       {
48772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48773       };
48774     } catch (...) {
48775       {
48776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48777       };
48778     }
48779   }
48780
48781 }
48782
48783
48784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48785   int jresult ;
48786   int result;
48787
48788   result = (int)Dali::Vector< float >::BaseType;
48789   jresult = (int)result;
48790   return jresult;
48791 }
48792
48793
48794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48795   void * jresult ;
48796   Dali::Vector< float > *result = 0 ;
48797
48798   {
48799     try {
48800       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48801     } catch (std::out_of_range& e) {
48802       {
48803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48804       };
48805     } catch (std::exception& e) {
48806       {
48807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48808       };
48809     } catch (Dali::DaliException e) {
48810       {
48811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48812       };
48813     } catch (...) {
48814       {
48815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48816       };
48817     }
48818   }
48819
48820   jresult = (void *)result;
48821   return jresult;
48822 }
48823
48824
48825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48826   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48827
48828   arg1 = (Dali::Vector< float > *)jarg1;
48829   {
48830     try {
48831       delete arg1;
48832     } catch (std::out_of_range& e) {
48833       {
48834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48835       };
48836     } catch (std::exception& e) {
48837       {
48838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48839       };
48840     } catch (Dali::DaliException e) {
48841       {
48842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48843       };
48844     } catch (...) {
48845       {
48846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48847       };
48848     }
48849   }
48850
48851 }
48852
48853
48854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48855   void * jresult ;
48856   Dali::Vector< float > *arg1 = 0 ;
48857   Dali::Vector< float > *result = 0 ;
48858
48859   arg1 = (Dali::Vector< float > *)jarg1;
48860   if (!arg1) {
48861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48862     return 0;
48863   }
48864   {
48865     try {
48866       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48867     } catch (std::out_of_range& e) {
48868       {
48869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48870       };
48871     } catch (std::exception& e) {
48872       {
48873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48874       };
48875     } catch (Dali::DaliException e) {
48876       {
48877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48878       };
48879     } catch (...) {
48880       {
48881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48882       };
48883     }
48884   }
48885
48886   jresult = (void *)result;
48887   return jresult;
48888 }
48889
48890
48891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48892   void * jresult ;
48893   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48894   Dali::Vector< float > *arg2 = 0 ;
48895   Dali::Vector< float > *result = 0 ;
48896
48897   arg1 = (Dali::Vector< float > *)jarg1;
48898   arg2 = (Dali::Vector< float > *)jarg2;
48899   if (!arg2) {
48900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48901     return 0;
48902   }
48903   {
48904     try {
48905       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48906     } catch (std::out_of_range& e) {
48907       {
48908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48909       };
48910     } catch (std::exception& e) {
48911       {
48912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48913       };
48914     } catch (Dali::DaliException e) {
48915       {
48916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48917       };
48918     } catch (...) {
48919       {
48920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48921       };
48922     }
48923   }
48924
48925   jresult = (void *)result;
48926   return jresult;
48927 }
48928
48929
48930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48931   void * jresult ;
48932   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48933   Dali::Vector< float >::Iterator result;
48934
48935   arg1 = (Dali::Vector< float > *)jarg1;
48936   {
48937     try {
48938       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48939     } catch (std::out_of_range& e) {
48940       {
48941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48942       };
48943     } catch (std::exception& e) {
48944       {
48945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48946       };
48947     } catch (Dali::DaliException e) {
48948       {
48949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48950       };
48951     } catch (...) {
48952       {
48953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48954       };
48955     }
48956   }
48957
48958   jresult = (void *)result;
48959   return jresult;
48960 }
48961
48962
48963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48964   void * jresult ;
48965   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48966   Dali::Vector< float >::Iterator result;
48967
48968   arg1 = (Dali::Vector< float > *)jarg1;
48969   {
48970     try {
48971       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48972     } catch (std::out_of_range& e) {
48973       {
48974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48975       };
48976     } catch (std::exception& e) {
48977       {
48978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48979       };
48980     } catch (Dali::DaliException e) {
48981       {
48982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48983       };
48984     } catch (...) {
48985       {
48986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48987       };
48988     }
48989   }
48990
48991   jresult = (void *)result;
48992   return jresult;
48993 }
48994
48995
48996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48997   void * jresult ;
48998   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48999   Dali::Vector< float >::SizeType arg2 ;
49000   Dali::Vector< float >::ItemType *result = 0 ;
49001
49002   arg1 = (Dali::Vector< float > *)jarg1;
49003   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49004   {
49005     try {
49006       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
49007     } catch (std::out_of_range& e) {
49008       {
49009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49010       };
49011     } catch (std::exception& e) {
49012       {
49013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49014       };
49015     } catch (Dali::DaliException e) {
49016       {
49017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49018       };
49019     } catch (...) {
49020       {
49021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49022       };
49023     }
49024   }
49025
49026   jresult = (void *)result;
49027   return jresult;
49028 }
49029
49030
49031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
49032   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49033   Dali::Vector< float >::ItemType *arg2 = 0 ;
49034   Dali::Vector< float >::ItemType temp2 ;
49035
49036   arg1 = (Dali::Vector< float > *)jarg1;
49037   temp2 = (Dali::Vector< float >::ItemType)jarg2;
49038   arg2 = &temp2;
49039   {
49040     try {
49041       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
49042     } catch (std::out_of_range& e) {
49043       {
49044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49045       };
49046     } catch (std::exception& e) {
49047       {
49048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49049       };
49050     } catch (Dali::DaliException e) {
49051       {
49052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49053       };
49054     } catch (...) {
49055       {
49056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49057       };
49058     }
49059   }
49060
49061 }
49062
49063
49064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
49065   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49066   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49067   Dali::Vector< float >::ItemType *arg3 = 0 ;
49068   Dali::Vector< float >::ItemType temp3 ;
49069
49070   arg1 = (Dali::Vector< float > *)jarg1;
49071   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49072   temp3 = (Dali::Vector< float >::ItemType)jarg3;
49073   arg3 = &temp3;
49074   {
49075     try {
49076       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
49077     } catch (std::out_of_range& e) {
49078       {
49079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49080       };
49081     } catch (std::exception& e) {
49082       {
49083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49084       };
49085     } catch (Dali::DaliException e) {
49086       {
49087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49088       };
49089     } catch (...) {
49090       {
49091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49092       };
49093     }
49094   }
49095
49096 }
49097
49098
49099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49100   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49101   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49102   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49103   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
49104
49105   arg1 = (Dali::Vector< float > *)jarg1;
49106   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49107   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49108   arg4 = (Dali::Vector< float >::Iterator)jarg4;
49109   {
49110     try {
49111       (arg1)->Insert(arg2,arg3,arg4);
49112     } catch (std::out_of_range& e) {
49113       {
49114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49115       };
49116     } catch (std::exception& e) {
49117       {
49118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49119       };
49120     } catch (Dali::DaliException e) {
49121       {
49122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49123       };
49124     } catch (...) {
49125       {
49126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49127       };
49128     }
49129   }
49130
49131 }
49132
49133
49134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
49135   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49136   Dali::Vector< float >::SizeType arg2 ;
49137
49138   arg1 = (Dali::Vector< float > *)jarg1;
49139   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49140   {
49141     try {
49142       (arg1)->Reserve(arg2);
49143     } catch (std::out_of_range& e) {
49144       {
49145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49146       };
49147     } catch (std::exception& e) {
49148       {
49149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49150       };
49151     } catch (Dali::DaliException e) {
49152       {
49153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49154       };
49155     } catch (...) {
49156       {
49157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49158       };
49159     }
49160   }
49161
49162 }
49163
49164 //// ========================= end of part 2 =============================
49165
49166 //// ========================== start part 3 ===============================
49167
49168
49169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49170   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49171   Dali::Vector< float >::SizeType arg2 ;
49172
49173   arg1 = (Dali::Vector< float > *)jarg1;
49174   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49175   {
49176     try {
49177       (arg1)->Resize(arg2);
49178     } catch (std::out_of_range& e) {
49179       {
49180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49181       };
49182     } catch (std::exception& e) {
49183       {
49184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49185       };
49186     } catch (Dali::DaliException e) {
49187       {
49188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49189       };
49190     } catch (...) {
49191       {
49192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49193       };
49194     }
49195   }
49196
49197 }
49198
49199
49200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
49201   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49202   Dali::Vector< float >::SizeType arg2 ;
49203   Dali::Vector< float >::ItemType *arg3 = 0 ;
49204   Dali::Vector< float >::ItemType temp3 ;
49205
49206   arg1 = (Dali::Vector< float > *)jarg1;
49207   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49208   temp3 = (Dali::Vector< float >::ItemType)jarg3;
49209   arg3 = &temp3;
49210   {
49211     try {
49212       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
49213     } catch (std::out_of_range& e) {
49214       {
49215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49216       };
49217     } catch (std::exception& e) {
49218       {
49219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49220       };
49221     } catch (Dali::DaliException e) {
49222       {
49223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49224       };
49225     } catch (...) {
49226       {
49227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49228       };
49229     }
49230   }
49231
49232 }
49233
49234
49235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
49236   void * jresult ;
49237   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49238   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49239   Dali::Vector< float >::Iterator result;
49240
49241   arg1 = (Dali::Vector< float > *)jarg1;
49242   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49243   {
49244     try {
49245       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
49246     } catch (std::out_of_range& e) {
49247       {
49248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49249       };
49250     } catch (std::exception& e) {
49251       {
49252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49253       };
49254     } catch (Dali::DaliException e) {
49255       {
49256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49257       };
49258     } catch (...) {
49259       {
49260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49261       };
49262     }
49263   }
49264
49265   jresult = (void *)result;
49266   return jresult;
49267 }
49268
49269
49270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49271   void * jresult ;
49272   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49273   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49274   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49275   Dali::Vector< float >::Iterator result;
49276
49277   arg1 = (Dali::Vector< float > *)jarg1;
49278   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49279   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49280   {
49281     try {
49282       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
49283     } catch (std::out_of_range& e) {
49284       {
49285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49286       };
49287     } catch (std::exception& e) {
49288       {
49289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49290       };
49291     } catch (Dali::DaliException e) {
49292       {
49293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49294       };
49295     } catch (...) {
49296       {
49297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49298       };
49299     }
49300   }
49301
49302   jresult = (void *)result;
49303   return jresult;
49304 }
49305
49306
49307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
49308   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49309   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49310
49311   arg1 = (Dali::Vector< float > *)jarg1;
49312   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49313   {
49314     try {
49315       (arg1)->Remove(arg2);
49316     } catch (std::out_of_range& e) {
49317       {
49318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49319       };
49320     } catch (std::exception& e) {
49321       {
49322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49323       };
49324     } catch (Dali::DaliException e) {
49325       {
49326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49327       };
49328     } catch (...) {
49329       {
49330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49331       };
49332     }
49333   }
49334
49335 }
49336
49337
49338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
49339   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49340   Dali::Vector< float > *arg2 = 0 ;
49341
49342   arg1 = (Dali::Vector< float > *)jarg1;
49343   arg2 = (Dali::Vector< float > *)jarg2;
49344   if (!arg2) {
49345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
49346     return ;
49347   }
49348   {
49349     try {
49350       (arg1)->Swap(*arg2);
49351     } catch (std::out_of_range& e) {
49352       {
49353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49354       };
49355     } catch (std::exception& e) {
49356       {
49357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49358       };
49359     } catch (Dali::DaliException e) {
49360       {
49361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49362       };
49363     } catch (...) {
49364       {
49365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49366       };
49367     }
49368   }
49369
49370 }
49371
49372
49373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
49374   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49375
49376   arg1 = (Dali::Vector< float > *)jarg1;
49377   {
49378     try {
49379       (arg1)->Clear();
49380     } catch (std::out_of_range& e) {
49381       {
49382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49383       };
49384     } catch (std::exception& e) {
49385       {
49386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49387       };
49388     } catch (Dali::DaliException e) {
49389       {
49390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49391       };
49392     } catch (...) {
49393       {
49394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49395       };
49396     }
49397   }
49398
49399 }
49400
49401
49402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
49403   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49404
49405   arg1 = (Dali::Vector< float > *)jarg1;
49406   {
49407     try {
49408       (arg1)->Release();
49409     } catch (std::out_of_range& e) {
49410       {
49411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49412       };
49413     } catch (std::exception& e) {
49414       {
49415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49416       };
49417     } catch (Dali::DaliException e) {
49418       {
49419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49420       };
49421     } catch (...) {
49422       {
49423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49424       };
49425     }
49426   }
49427
49428 }
49429
49430
49431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
49432   int jresult ;
49433   int result;
49434
49435   result = (int)Dali::Vector< unsigned char >::BaseType;
49436   jresult = (int)result;
49437   return jresult;
49438 }
49439
49440
49441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
49442   void * jresult ;
49443   Dali::Vector< unsigned char > *result = 0 ;
49444
49445   {
49446     try {
49447       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
49448     } catch (std::out_of_range& e) {
49449       {
49450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49451       };
49452     } catch (std::exception& e) {
49453       {
49454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49455       };
49456     } catch (Dali::DaliException e) {
49457       {
49458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49459       };
49460     } catch (...) {
49461       {
49462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49463       };
49464     }
49465   }
49466
49467   jresult = (void *)result;
49468   return jresult;
49469 }
49470
49471
49472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
49473   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49474
49475   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49476   {
49477     try {
49478       delete arg1;
49479     } catch (std::out_of_range& e) {
49480       {
49481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49482       };
49483     } catch (std::exception& e) {
49484       {
49485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49486       };
49487     } catch (Dali::DaliException e) {
49488       {
49489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49490       };
49491     } catch (...) {
49492       {
49493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49494       };
49495     }
49496   }
49497
49498 }
49499
49500
49501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
49502   void * jresult ;
49503   Dali::Vector< unsigned char > *arg1 = 0 ;
49504   Dali::Vector< unsigned char > *result = 0 ;
49505
49506   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49507   if (!arg1) {
49508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49509     return 0;
49510   }
49511   {
49512     try {
49513       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
49514     } catch (std::out_of_range& e) {
49515       {
49516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49517       };
49518     } catch (std::exception& e) {
49519       {
49520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49521       };
49522     } catch (Dali::DaliException e) {
49523       {
49524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49525       };
49526     } catch (...) {
49527       {
49528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49529       };
49530     }
49531   }
49532
49533   jresult = (void *)result;
49534   return jresult;
49535 }
49536
49537
49538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49539   void * jresult ;
49540   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49541   Dali::Vector< unsigned char > *arg2 = 0 ;
49542   Dali::Vector< unsigned char > *result = 0 ;
49543
49544   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49545   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49546   if (!arg2) {
49547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49548     return 0;
49549   }
49550   {
49551     try {
49552       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49553     } catch (std::out_of_range& e) {
49554       {
49555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49556       };
49557     } catch (std::exception& e) {
49558       {
49559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49560       };
49561     } catch (Dali::DaliException e) {
49562       {
49563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49564       };
49565     } catch (...) {
49566       {
49567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49568       };
49569     }
49570   }
49571
49572   jresult = (void *)result;
49573   return jresult;
49574 }
49575
49576
49577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49578   void * jresult ;
49579   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49580   Dali::Vector< unsigned char >::Iterator result;
49581
49582   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49583   {
49584     try {
49585       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49586     } catch (std::out_of_range& e) {
49587       {
49588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49589       };
49590     } catch (std::exception& e) {
49591       {
49592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49593       };
49594     } catch (Dali::DaliException e) {
49595       {
49596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49597       };
49598     } catch (...) {
49599       {
49600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49601       };
49602     }
49603   }
49604
49605   jresult = (void *)result;
49606   return jresult;
49607 }
49608
49609
49610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49611   void * jresult ;
49612   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49613   Dali::Vector< unsigned char >::Iterator result;
49614
49615   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49616   {
49617     try {
49618       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49619     } catch (std::out_of_range& e) {
49620       {
49621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49622       };
49623     } catch (std::exception& e) {
49624       {
49625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49626       };
49627     } catch (Dali::DaliException e) {
49628       {
49629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49630       };
49631     } catch (...) {
49632       {
49633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49634       };
49635     }
49636   }
49637
49638   jresult = (void *)result;
49639   return jresult;
49640 }
49641
49642
49643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49644   void * jresult ;
49645   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49646   Dali::Vector< unsigned char >::SizeType arg2 ;
49647   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49648
49649   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49650   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49651   {
49652     try {
49653       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49654     } catch (std::out_of_range& e) {
49655       {
49656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49657       };
49658     } catch (std::exception& e) {
49659       {
49660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49661       };
49662     } catch (Dali::DaliException e) {
49663       {
49664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49665       };
49666     } catch (...) {
49667       {
49668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49669       };
49670     }
49671   }
49672
49673   jresult = (void *)result;
49674   return jresult;
49675 }
49676
49677
49678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49679   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49680   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49681   Dali::Vector< unsigned char >::ItemType temp2 ;
49682
49683   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49684   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49685   arg2 = &temp2;
49686   {
49687     try {
49688       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49689     } catch (std::out_of_range& e) {
49690       {
49691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49692       };
49693     } catch (std::exception& e) {
49694       {
49695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49696       };
49697     } catch (Dali::DaliException e) {
49698       {
49699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49700       };
49701     } catch (...) {
49702       {
49703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49704       };
49705     }
49706   }
49707
49708 }
49709
49710
49711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49712   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49713   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49714   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49715   Dali::Vector< unsigned char >::ItemType temp3 ;
49716
49717   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49718   arg2 = jarg2;
49719   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49720   arg3 = &temp3;
49721   {
49722     try {
49723       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49724     } catch (std::out_of_range& e) {
49725       {
49726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49727       };
49728     } catch (std::exception& e) {
49729       {
49730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49731       };
49732     } catch (Dali::DaliException e) {
49733       {
49734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49735       };
49736     } catch (...) {
49737       {
49738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49739       };
49740     }
49741   }
49742
49743
49744
49745 }
49746
49747
49748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49749   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49750   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49751   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49752   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49753
49754   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49755   arg2 = jarg2;
49756   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49757   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49758   {
49759     try {
49760       (arg1)->Insert(arg2,arg3,arg4);
49761     } catch (std::out_of_range& e) {
49762       {
49763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49764       };
49765     } catch (std::exception& e) {
49766       {
49767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49768       };
49769     } catch (Dali::DaliException e) {
49770       {
49771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49772       };
49773     } catch (...) {
49774       {
49775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49776       };
49777     }
49778   }
49779
49780
49781
49782 }
49783
49784
49785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49786   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49787   Dali::Vector< unsigned char >::SizeType arg2 ;
49788
49789   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49790   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49791   {
49792     try {
49793       (arg1)->Reserve(arg2);
49794     } catch (std::out_of_range& e) {
49795       {
49796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49797       };
49798     } catch (std::exception& e) {
49799       {
49800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49801       };
49802     } catch (Dali::DaliException e) {
49803       {
49804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49805       };
49806     } catch (...) {
49807       {
49808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49809       };
49810     }
49811   }
49812
49813 }
49814
49815
49816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49817   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49818   Dali::Vector< unsigned char >::SizeType arg2 ;
49819
49820   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49821   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49822   {
49823     try {
49824       (arg1)->Resize(arg2);
49825     } catch (std::out_of_range& e) {
49826       {
49827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49828       };
49829     } catch (std::exception& e) {
49830       {
49831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49832       };
49833     } catch (Dali::DaliException e) {
49834       {
49835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49836       };
49837     } catch (...) {
49838       {
49839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49840       };
49841     }
49842   }
49843
49844 }
49845
49846
49847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49848   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49849   Dali::Vector< unsigned char >::SizeType arg2 ;
49850   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49851   Dali::Vector< unsigned char >::ItemType temp3 ;
49852
49853   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49854   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49855   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49856   arg3 = &temp3;
49857   {
49858     try {
49859       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49860     } catch (std::out_of_range& e) {
49861       {
49862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49863       };
49864     } catch (std::exception& e) {
49865       {
49866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49867       };
49868     } catch (Dali::DaliException e) {
49869       {
49870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49871       };
49872     } catch (...) {
49873       {
49874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49875       };
49876     }
49877   }
49878
49879 }
49880
49881
49882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49883   void * jresult ;
49884   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49885   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49886   Dali::Vector< unsigned char >::Iterator result;
49887
49888   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49889   arg2 = jarg2;
49890   {
49891     try {
49892       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49893     } catch (std::out_of_range& e) {
49894       {
49895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49896       };
49897     } catch (std::exception& e) {
49898       {
49899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49900       };
49901     } catch (Dali::DaliException e) {
49902       {
49903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49904       };
49905     } catch (...) {
49906       {
49907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49908       };
49909     }
49910   }
49911
49912   jresult = (void *)result;
49913
49914
49915   return jresult;
49916 }
49917
49918
49919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49920   void * jresult ;
49921   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49922   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49923   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49924   Dali::Vector< unsigned char >::Iterator result;
49925
49926   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49927   arg2 = jarg2;
49928   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49929   {
49930     try {
49931       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49932     } catch (std::out_of_range& e) {
49933       {
49934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49935       };
49936     } catch (std::exception& e) {
49937       {
49938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49939       };
49940     } catch (Dali::DaliException e) {
49941       {
49942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49943       };
49944     } catch (...) {
49945       {
49946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49947       };
49948     }
49949   }
49950
49951   jresult = (void *)result;
49952
49953
49954   return jresult;
49955 }
49956
49957
49958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49959   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49960   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49961
49962   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49963   arg2 = jarg2;
49964   {
49965     try {
49966       (arg1)->Remove(arg2);
49967     } catch (std::out_of_range& e) {
49968       {
49969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49970       };
49971     } catch (std::exception& e) {
49972       {
49973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49974       };
49975     } catch (Dali::DaliException e) {
49976       {
49977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49978       };
49979     } catch (...) {
49980       {
49981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49982       };
49983     }
49984   }
49985
49986
49987
49988 }
49989
49990
49991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49992   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49993   Dali::Vector< unsigned char > *arg2 = 0 ;
49994
49995   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49996   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49997   if (!arg2) {
49998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49999     return ;
50000   }
50001   {
50002     try {
50003       (arg1)->Swap(*arg2);
50004     } catch (std::out_of_range& e) {
50005       {
50006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50007       };
50008     } catch (std::exception& e) {
50009       {
50010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50011       };
50012     } catch (Dali::DaliException e) {
50013       {
50014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50015       };
50016     } catch (...) {
50017       {
50018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50019       };
50020     }
50021   }
50022
50023 }
50024
50025
50026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
50027   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50028
50029   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50030   {
50031     try {
50032       (arg1)->Clear();
50033     } catch (std::out_of_range& e) {
50034       {
50035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50036       };
50037     } catch (std::exception& e) {
50038       {
50039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50040       };
50041     } catch (Dali::DaliException e) {
50042       {
50043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50044       };
50045     } catch (...) {
50046       {
50047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50048       };
50049     }
50050   }
50051
50052 }
50053
50054
50055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
50056   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50057
50058   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50059   {
50060     try {
50061       (arg1)->Release();
50062     } catch (std::out_of_range& e) {
50063       {
50064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50065       };
50066     } catch (std::exception& e) {
50067       {
50068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50069       };
50070     } catch (Dali::DaliException e) {
50071       {
50072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50073       };
50074     } catch (...) {
50075       {
50076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50077       };
50078     }
50079   }
50080
50081 }
50082
50083
50084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
50085   int jresult ;
50086   int result;
50087
50088   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
50089   jresult = (int)result;
50090   return jresult;
50091 }
50092
50093
50094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
50095   void * jresult ;
50096   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50097
50098   {
50099     try {
50100       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
50101     } catch (std::out_of_range& e) {
50102       {
50103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50104       };
50105     } catch (std::exception& e) {
50106       {
50107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50108       };
50109     } catch (Dali::DaliException e) {
50110       {
50111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50112       };
50113     } catch (...) {
50114       {
50115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50116       };
50117     }
50118   }
50119
50120   jresult = (void *)result;
50121   return jresult;
50122 }
50123
50124
50125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
50126   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50127
50128   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50129   {
50130     try {
50131       delete arg1;
50132     } catch (std::out_of_range& e) {
50133       {
50134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50135       };
50136     } catch (std::exception& e) {
50137       {
50138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50139       };
50140     } catch (Dali::DaliException e) {
50141       {
50142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50143       };
50144     } catch (...) {
50145       {
50146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50147       };
50148     }
50149   }
50150
50151 }
50152
50153
50154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
50155   void * jresult ;
50156   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
50157   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50158
50159   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50160   if (!arg1) {
50161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
50162     return 0;
50163   }
50164   {
50165     try {
50166       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
50167     } catch (std::out_of_range& e) {
50168       {
50169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50170       };
50171     } catch (std::exception& e) {
50172       {
50173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50174       };
50175     } catch (Dali::DaliException e) {
50176       {
50177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50178       };
50179     } catch (...) {
50180       {
50181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50182       };
50183     }
50184   }
50185
50186   jresult = (void *)result;
50187   return jresult;
50188 }
50189
50190
50191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
50192   void * jresult ;
50193   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50194   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50195   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50196
50197   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50198   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50199   if (!arg2) {
50200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
50201     return 0;
50202   }
50203   {
50204     try {
50205       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
50206     } catch (std::out_of_range& e) {
50207       {
50208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50209       };
50210     } catch (std::exception& e) {
50211       {
50212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50213       };
50214     } catch (Dali::DaliException e) {
50215       {
50216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50217       };
50218     } catch (...) {
50219       {
50220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50221       };
50222     }
50223   }
50224
50225   jresult = (void *)result;
50226   return jresult;
50227 }
50228
50229
50230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
50231   void * jresult ;
50232   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50233   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50234
50235   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50236   {
50237     try {
50238       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
50239     } catch (std::out_of_range& e) {
50240       {
50241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50242       };
50243     } catch (std::exception& e) {
50244       {
50245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50246       };
50247     } catch (Dali::DaliException e) {
50248       {
50249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50250       };
50251     } catch (...) {
50252       {
50253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50254       };
50255     }
50256   }
50257
50258   jresult = (void *)result;
50259   return jresult;
50260 }
50261
50262
50263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
50264   void * jresult ;
50265   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50266   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50267
50268   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50269   {
50270     try {
50271       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
50272     } catch (std::out_of_range& e) {
50273       {
50274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50275       };
50276     } catch (std::exception& e) {
50277       {
50278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50279       };
50280     } catch (Dali::DaliException e) {
50281       {
50282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50283       };
50284     } catch (...) {
50285       {
50286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50287       };
50288     }
50289   }
50290
50291   jresult = (void *)result;
50292   return jresult;
50293 }
50294
50295
50296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50297   void * jresult ;
50298   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50299   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50300   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
50301
50302   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50303   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50304   {
50305     try {
50306       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
50307     } catch (std::out_of_range& e) {
50308       {
50309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50310       };
50311     } catch (std::exception& e) {
50312       {
50313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50314       };
50315     } catch (Dali::DaliException e) {
50316       {
50317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50318       };
50319     } catch (...) {
50320       {
50321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50322       };
50323     }
50324   }
50325
50326   jresult = (void *)result;
50327   return jresult;
50328 }
50329
50330
50331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
50332   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50333   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
50334
50335   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50336   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
50337   if (!arg2) {
50338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50339     return ;
50340   }
50341   {
50342     try {
50343       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
50344     } catch (std::out_of_range& e) {
50345       {
50346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50347       };
50348     } catch (std::exception& e) {
50349       {
50350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50351       };
50352     } catch (Dali::DaliException e) {
50353       {
50354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50355       };
50356     } catch (...) {
50357       {
50358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50359       };
50360     }
50361   }
50362
50363 }
50364
50365
50366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
50367   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50368   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50369   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50370
50371   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50372   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50373   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50374   if (!arg3) {
50375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50376     return ;
50377   }
50378   {
50379     try {
50380       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50381     } catch (std::out_of_range& e) {
50382       {
50383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50384       };
50385     } catch (std::exception& e) {
50386       {
50387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50388       };
50389     } catch (Dali::DaliException e) {
50390       {
50391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50392       };
50393     } catch (...) {
50394       {
50395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50396       };
50397     }
50398   }
50399
50400 }
50401
50402
50403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
50404   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50405   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50406   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50407   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50408
50409   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50410   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50411   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50412   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
50413   {
50414     try {
50415       (arg1)->Insert(arg2,arg3,arg4);
50416     } catch (std::out_of_range& e) {
50417       {
50418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50419       };
50420     } catch (std::exception& e) {
50421       {
50422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50423       };
50424     } catch (Dali::DaliException e) {
50425       {
50426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50427       };
50428     } catch (...) {
50429       {
50430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50431       };
50432     }
50433   }
50434
50435 }
50436
50437
50438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
50439   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50440   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50441
50442   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50443   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50444   {
50445     try {
50446       (arg1)->Reserve(arg2);
50447     } catch (std::out_of_range& e) {
50448       {
50449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50450       };
50451     } catch (std::exception& e) {
50452       {
50453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50454       };
50455     } catch (Dali::DaliException e) {
50456       {
50457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50458       };
50459     } catch (...) {
50460       {
50461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50462       };
50463     }
50464   }
50465
50466 }
50467
50468
50469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50470   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50471   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50472
50473   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50474   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50475   {
50476     try {
50477       (arg1)->Resize(arg2);
50478     } catch (std::out_of_range& e) {
50479       {
50480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50481       };
50482     } catch (std::exception& e) {
50483       {
50484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50485       };
50486     } catch (Dali::DaliException e) {
50487       {
50488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50489       };
50490     } catch (...) {
50491       {
50492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50493       };
50494     }
50495   }
50496
50497 }
50498
50499
50500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
50501   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50502   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50503   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50504
50505   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50506   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50507   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50508   if (!arg3) {
50509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50510     return ;
50511   }
50512   {
50513     try {
50514       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50515     } catch (std::out_of_range& e) {
50516       {
50517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50518       };
50519     } catch (std::exception& e) {
50520       {
50521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50522       };
50523     } catch (Dali::DaliException e) {
50524       {
50525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50526       };
50527     } catch (...) {
50528       {
50529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50530       };
50531     }
50532   }
50533
50534 }
50535
50536
50537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50538   void * jresult ;
50539   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50540   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50541   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50542
50543   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50544   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50545   {
50546     try {
50547       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50548     } catch (std::out_of_range& e) {
50549       {
50550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50551       };
50552     } catch (std::exception& e) {
50553       {
50554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50555       };
50556     } catch (Dali::DaliException e) {
50557       {
50558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50559       };
50560     } catch (...) {
50561       {
50562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50563       };
50564     }
50565   }
50566
50567   jresult = (void *)result;
50568   return jresult;
50569 }
50570
50571
50572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50573   void * jresult ;
50574   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50575   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50576   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50577   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50578
50579   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50580   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50581   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50582   {
50583     try {
50584       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50585     } catch (std::out_of_range& e) {
50586       {
50587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50588       };
50589     } catch (std::exception& e) {
50590       {
50591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50592       };
50593     } catch (Dali::DaliException e) {
50594       {
50595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50596       };
50597     } catch (...) {
50598       {
50599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50600       };
50601     }
50602   }
50603
50604   jresult = (void *)result;
50605   return jresult;
50606 }
50607
50608
50609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50610   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50611   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50612
50613   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50614   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50615   {
50616     try {
50617       (arg1)->Remove(arg2);
50618     } catch (std::out_of_range& e) {
50619       {
50620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50621       };
50622     } catch (std::exception& e) {
50623       {
50624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50625       };
50626     } catch (Dali::DaliException e) {
50627       {
50628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50629       };
50630     } catch (...) {
50631       {
50632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50633       };
50634     }
50635   }
50636
50637 }
50638
50639
50640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50641   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50642   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50643
50644   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50645   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50646   if (!arg2) {
50647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50648     return ;
50649   }
50650   {
50651     try {
50652       (arg1)->Swap(*arg2);
50653     } catch (std::out_of_range& e) {
50654       {
50655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50656       };
50657     } catch (std::exception& e) {
50658       {
50659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50660       };
50661     } catch (Dali::DaliException e) {
50662       {
50663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50664       };
50665     } catch (...) {
50666       {
50667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50668       };
50669     }
50670   }
50671
50672 }
50673
50674
50675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50676   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50677
50678   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50679   {
50680     try {
50681       (arg1)->Clear();
50682     } catch (std::out_of_range& e) {
50683       {
50684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50685       };
50686     } catch (std::exception& e) {
50687       {
50688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50689       };
50690     } catch (Dali::DaliException e) {
50691       {
50692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50693       };
50694     } catch (...) {
50695       {
50696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50697       };
50698     }
50699   }
50700
50701 }
50702
50703
50704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50705   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50706
50707   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50708   {
50709     try {
50710       (arg1)->Release();
50711     } catch (std::out_of_range& e) {
50712       {
50713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50714       };
50715     } catch (std::exception& e) {
50716       {
50717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50718       };
50719     } catch (Dali::DaliException e) {
50720       {
50721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50722       };
50723     } catch (...) {
50724       {
50725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50726       };
50727     }
50728   }
50729
50730 }
50731
50732
50733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50734   void * jresult ;
50735   Dali::Signal< void () > *result = 0 ;
50736
50737   {
50738     try {
50739       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50740     } catch (std::out_of_range& e) {
50741       {
50742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50743       };
50744     } catch (std::exception& e) {
50745       {
50746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50747       };
50748     } catch (Dali::DaliException e) {
50749       {
50750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50751       };
50752     } catch (...) {
50753       {
50754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50755       };
50756     }
50757   }
50758
50759   jresult = (void *)result;
50760   return jresult;
50761 }
50762
50763
50764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50765   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50766
50767   arg1 = (Dali::Signal< void () > *)jarg1;
50768   {
50769     try {
50770       delete arg1;
50771     } catch (std::out_of_range& e) {
50772       {
50773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50774       };
50775     } catch (std::exception& e) {
50776       {
50777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50778       };
50779     } catch (Dali::DaliException e) {
50780       {
50781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50782       };
50783     } catch (...) {
50784       {
50785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50786       };
50787     }
50788   }
50789
50790 }
50791
50792
50793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50794   unsigned int jresult ;
50795   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50796   bool result;
50797
50798   arg1 = (Dali::Signal< void () > *)jarg1;
50799   {
50800     try {
50801       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50802     } catch (std::out_of_range& e) {
50803       {
50804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50805       };
50806     } catch (std::exception& e) {
50807       {
50808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50809       };
50810     } catch (Dali::DaliException e) {
50811       {
50812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50813       };
50814     } catch (...) {
50815       {
50816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50817       };
50818     }
50819   }
50820
50821   jresult = result;
50822   return jresult;
50823 }
50824
50825
50826 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50827   unsigned long jresult ;
50828   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50829   std::size_t result;
50830
50831   arg1 = (Dali::Signal< void () > *)jarg1;
50832   {
50833     try {
50834       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50835     } catch (std::out_of_range& e) {
50836       {
50837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50838       };
50839     } catch (std::exception& e) {
50840       {
50841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50842       };
50843     } catch (Dali::DaliException e) {
50844       {
50845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50846       };
50847     } catch (...) {
50848       {
50849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50850       };
50851     }
50852   }
50853
50854   jresult = (unsigned long)result;
50855   return jresult;
50856 }
50857
50858
50859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50860   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50861   void (*arg2)() = (void (*)()) 0 ;
50862
50863   arg1 = (Dali::Signal< void () > *)jarg1;
50864   arg2 = (void (*)())jarg2;
50865   {
50866     try {
50867       (arg1)->Connect(arg2);
50868     } catch (std::out_of_range& e) {
50869       {
50870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50871       };
50872     } catch (std::exception& e) {
50873       {
50874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50875       };
50876     } catch (Dali::DaliException e) {
50877       {
50878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50879       };
50880     } catch (...) {
50881       {
50882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50883       };
50884     }
50885   }
50886
50887 }
50888
50889
50890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50891   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50892   void (*arg2)() = (void (*)()) 0 ;
50893
50894   arg1 = (Dali::Signal< void () > *)jarg1;
50895   arg2 = (void (*)())jarg2;
50896   {
50897     try {
50898       (arg1)->Disconnect(arg2);
50899     } catch (std::out_of_range& e) {
50900       {
50901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50902       };
50903     } catch (std::exception& e) {
50904       {
50905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50906       };
50907     } catch (Dali::DaliException e) {
50908       {
50909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50910       };
50911     } catch (...) {
50912       {
50913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50914       };
50915     }
50916   }
50917
50918 }
50919
50920
50921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50922   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50923   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50924   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50925
50926   arg1 = (Dali::Signal< void () > *)jarg1;
50927   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50928   arg3 = (Dali::FunctorDelegate *)jarg3;
50929   {
50930     try {
50931       (arg1)->Connect(arg2,arg3);
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 void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50955   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50956
50957   arg1 = (Dali::Signal< void () > *)jarg1;
50958   {
50959     try {
50960       (arg1)->Emit();
50961     } catch (std::out_of_range& e) {
50962       {
50963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50964       };
50965     } catch (std::exception& e) {
50966       {
50967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50968       };
50969     } catch (Dali::DaliException e) {
50970       {
50971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50972       };
50973     } catch (...) {
50974       {
50975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50976       };
50977     }
50978   }
50979
50980 }
50981
50982
50983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50984   unsigned int jresult ;
50985   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50986   bool result;
50987
50988   arg1 = (Dali::Signal< void (float) > *)jarg1;
50989   {
50990     try {
50991       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50992     } catch (std::out_of_range& e) {
50993       {
50994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50995       };
50996     } catch (std::exception& e) {
50997       {
50998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50999       };
51000     } catch (Dali::DaliException e) {
51001       {
51002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51003       };
51004     } catch (...) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51007       };
51008     }
51009   }
51010
51011   jresult = result;
51012   return jresult;
51013 }
51014
51015
51016 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
51017   unsigned long jresult ;
51018   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51019   std::size_t result;
51020
51021   arg1 = (Dali::Signal< void (float) > *)jarg1;
51022   {
51023     try {
51024       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
51025     } catch (std::out_of_range& e) {
51026       {
51027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51028       };
51029     } catch (std::exception& e) {
51030       {
51031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51032       };
51033     } catch (Dali::DaliException e) {
51034       {
51035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51036       };
51037     } catch (...) {
51038       {
51039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51040       };
51041     }
51042   }
51043
51044   jresult = (unsigned long)result;
51045   return jresult;
51046 }
51047
51048
51049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
51050   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51051   void (*arg2)(float) = (void (*)(float)) 0 ;
51052
51053   arg1 = (Dali::Signal< void (float) > *)jarg1;
51054   arg2 = (void (*)(float))jarg2;
51055   {
51056     try {
51057       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
51058     } catch (std::out_of_range& e) {
51059       {
51060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51061       };
51062     } catch (std::exception& e) {
51063       {
51064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51065       };
51066     } catch (Dali::DaliException e) {
51067       {
51068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51069       };
51070     } catch (...) {
51071       {
51072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51073       };
51074     }
51075   }
51076
51077 }
51078
51079
51080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
51081   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51082   void (*arg2)(float) = (void (*)(float)) 0 ;
51083
51084   arg1 = (Dali::Signal< void (float) > *)jarg1;
51085   arg2 = (void (*)(float))jarg2;
51086   {
51087     try {
51088       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
51089     } catch (std::out_of_range& e) {
51090       {
51091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51092       };
51093     } catch (std::exception& e) {
51094       {
51095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51096       };
51097     } catch (Dali::DaliException e) {
51098       {
51099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51100       };
51101     } catch (...) {
51102       {
51103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51104       };
51105     }
51106   }
51107
51108 }
51109
51110
51111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
51112   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51113   float arg2 ;
51114
51115   arg1 = (Dali::Signal< void (float) > *)jarg1;
51116   arg2 = (float)jarg2;
51117   {
51118     try {
51119       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
51120     } catch (std::out_of_range& e) {
51121       {
51122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51123       };
51124     } catch (std::exception& e) {
51125       {
51126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51127       };
51128     } catch (Dali::DaliException e) {
51129       {
51130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51131       };
51132     } catch (...) {
51133       {
51134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51135       };
51136     }
51137   }
51138
51139 }
51140
51141
51142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
51143   void * jresult ;
51144   Dali::Signal< void (float) > *result = 0 ;
51145
51146   {
51147     try {
51148       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
51149     } catch (std::out_of_range& e) {
51150       {
51151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51152       };
51153     } catch (std::exception& e) {
51154       {
51155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51156       };
51157     } catch (Dali::DaliException e) {
51158       {
51159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51160       };
51161     } catch (...) {
51162       {
51163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51164       };
51165     }
51166   }
51167
51168   jresult = (void *)result;
51169   return jresult;
51170 }
51171
51172
51173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
51174   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51175
51176   arg1 = (Dali::Signal< void (float) > *)jarg1;
51177   {
51178     try {
51179       delete arg1;
51180     } catch (std::out_of_range& e) {
51181       {
51182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51183       };
51184     } catch (std::exception& e) {
51185       {
51186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51187       };
51188     } catch (Dali::DaliException e) {
51189       {
51190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51191       };
51192     } catch (...) {
51193       {
51194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51195       };
51196     }
51197   }
51198
51199 }
51200
51201
51202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
51203   unsigned int jresult ;
51204   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51205   bool result;
51206
51207   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51208   {
51209     try {
51210       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
51211     } catch (std::out_of_range& e) {
51212       {
51213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51214       };
51215     } catch (std::exception& e) {
51216       {
51217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51218       };
51219     } catch (Dali::DaliException e) {
51220       {
51221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51222       };
51223     } catch (...) {
51224       {
51225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51226       };
51227     }
51228   }
51229
51230   jresult = result;
51231   return jresult;
51232 }
51233
51234
51235 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
51236   unsigned long jresult ;
51237   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51238   std::size_t result;
51239
51240   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51241   {
51242     try {
51243       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
51244     } catch (std::out_of_range& e) {
51245       {
51246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51247       };
51248     } catch (std::exception& e) {
51249       {
51250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51251       };
51252     } catch (Dali::DaliException e) {
51253       {
51254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51255       };
51256     } catch (...) {
51257       {
51258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51259       };
51260     }
51261   }
51262
51263   jresult = (unsigned long)result;
51264   return jresult;
51265 }
51266
51267
51268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
51269   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51270   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51271
51272   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51273   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51274   {
51275     try {
51276       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
51277     } catch (std::out_of_range& e) {
51278       {
51279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51280       };
51281     } catch (std::exception& e) {
51282       {
51283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51284       };
51285     } catch (Dali::DaliException e) {
51286       {
51287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51288       };
51289     } catch (...) {
51290       {
51291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51292       };
51293     }
51294   }
51295
51296 }
51297
51298
51299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
51300   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51301   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51302
51303   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51304   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51305   {
51306     try {
51307       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
51308     } catch (std::out_of_range& e) {
51309       {
51310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51311       };
51312     } catch (std::exception& e) {
51313       {
51314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51315       };
51316     } catch (Dali::DaliException e) {
51317       {
51318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51319       };
51320     } catch (...) {
51321       {
51322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51323       };
51324     }
51325   }
51326
51327 }
51328
51329
51330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
51331   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51332   Dali::BaseHandle arg2 ;
51333   Dali::BaseHandle *argp2 ;
51334
51335   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51336   argp2 = (Dali::BaseHandle *)jarg2;
51337   if (!argp2) {
51338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51339     return ;
51340   }
51341   arg2 = *argp2;
51342   {
51343     try {
51344       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
51345     } catch (std::out_of_range& e) {
51346       {
51347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51348       };
51349     } catch (std::exception& e) {
51350       {
51351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51352       };
51353     } catch (Dali::DaliException e) {
51354       {
51355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51356       };
51357     } catch (...) {
51358       {
51359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51360       };
51361     }
51362   }
51363
51364 }
51365
51366
51367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
51368   void * jresult ;
51369   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
51370
51371   {
51372     try {
51373       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
51374     } catch (std::out_of_range& e) {
51375       {
51376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51377       };
51378     } catch (std::exception& e) {
51379       {
51380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51381       };
51382     } catch (Dali::DaliException e) {
51383       {
51384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51385       };
51386     } catch (...) {
51387       {
51388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51389       };
51390     }
51391   }
51392
51393   jresult = (void *)result;
51394   return jresult;
51395 }
51396
51397
51398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
51399   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51400
51401   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51402   {
51403     try {
51404       delete arg1;
51405     } catch (std::out_of_range& e) {
51406       {
51407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51408       };
51409     } catch (std::exception& e) {
51410       {
51411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51412       };
51413     } catch (Dali::DaliException e) {
51414       {
51415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51416       };
51417     } catch (...) {
51418       {
51419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51420       };
51421     }
51422   }
51423
51424 }
51425
51426
51427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
51428   unsigned int jresult ;
51429   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51430   bool result;
51431
51432   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51433   {
51434     try {
51435       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51436     } catch (std::out_of_range& e) {
51437       {
51438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51439       };
51440     } catch (std::exception& e) {
51441       {
51442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51443       };
51444     } catch (Dali::DaliException e) {
51445       {
51446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51447       };
51448     } catch (...) {
51449       {
51450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51451       };
51452     }
51453   }
51454
51455   jresult = result;
51456   return jresult;
51457 }
51458
51459
51460 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
51461   unsigned long jresult ;
51462   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51463   std::size_t result;
51464
51465   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51466   {
51467     try {
51468       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51469     } catch (std::out_of_range& e) {
51470       {
51471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51472       };
51473     } catch (std::exception& e) {
51474       {
51475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51476       };
51477     } catch (Dali::DaliException e) {
51478       {
51479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51480       };
51481     } catch (...) {
51482       {
51483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51484       };
51485     }
51486   }
51487
51488   jresult = (unsigned long)result;
51489   return jresult;
51490 }
51491
51492
51493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
51494   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51495   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51496
51497   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51498   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51499   {
51500     try {
51501       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
51502     } catch (std::out_of_range& e) {
51503       {
51504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51505       };
51506     } catch (std::exception& e) {
51507       {
51508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51509       };
51510     } catch (Dali::DaliException e) {
51511       {
51512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51513       };
51514     } catch (...) {
51515       {
51516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51517       };
51518     }
51519   }
51520
51521 }
51522
51523
51524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51525   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51526   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51527
51528   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51529   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51530   {
51531     try {
51532       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51533     } catch (std::out_of_range& e) {
51534       {
51535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51536       };
51537     } catch (std::exception& e) {
51538       {
51539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51540       };
51541     } catch (Dali::DaliException e) {
51542       {
51543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51544       };
51545     } catch (...) {
51546       {
51547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51548       };
51549     }
51550   }
51551
51552 }
51553
51554
51555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51556   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51557   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51558
51559   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51560   arg2 = (Dali::RefObject *)jarg2;
51561   {
51562     try {
51563       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51564     } catch (std::out_of_range& e) {
51565       {
51566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51567       };
51568     } catch (std::exception& e) {
51569       {
51570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51571       };
51572     } catch (Dali::DaliException e) {
51573       {
51574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51575       };
51576     } catch (...) {
51577       {
51578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51579       };
51580     }
51581   }
51582
51583 }
51584
51585
51586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51587   void * jresult ;
51588   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51589
51590   {
51591     try {
51592       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51593     } catch (std::out_of_range& e) {
51594       {
51595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51596       };
51597     } catch (std::exception& e) {
51598       {
51599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51600       };
51601     } catch (Dali::DaliException e) {
51602       {
51603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51604       };
51605     } catch (...) {
51606       {
51607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51608       };
51609     }
51610   }
51611
51612   jresult = (void *)result;
51613   return jresult;
51614 }
51615
51616
51617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51618   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51619
51620   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51621   {
51622     try {
51623       delete arg1;
51624     } catch (std::out_of_range& e) {
51625       {
51626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51627       };
51628     } catch (std::exception& e) {
51629       {
51630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51631       };
51632     } catch (Dali::DaliException e) {
51633       {
51634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51635       };
51636     } catch (...) {
51637       {
51638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51639       };
51640     }
51641   }
51642
51643 }
51644
51645
51646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51647   unsigned int jresult ;
51648   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51649   bool result;
51650
51651   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51652   {
51653     try {
51654       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51655     } catch (std::out_of_range& e) {
51656       {
51657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51658       };
51659     } catch (std::exception& e) {
51660       {
51661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51662       };
51663     } catch (Dali::DaliException e) {
51664       {
51665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51666       };
51667     } catch (...) {
51668       {
51669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51670       };
51671     }
51672   }
51673
51674   jresult = result;
51675   return jresult;
51676 }
51677
51678
51679 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51680   unsigned long jresult ;
51681   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51682   std::size_t result;
51683
51684   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51685   {
51686     try {
51687       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51688     } catch (std::out_of_range& e) {
51689       {
51690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51691       };
51692     } catch (std::exception& e) {
51693       {
51694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51695       };
51696     } catch (Dali::DaliException e) {
51697       {
51698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51699       };
51700     } catch (...) {
51701       {
51702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51703       };
51704     }
51705   }
51706
51707   jresult = (unsigned long)result;
51708   return jresult;
51709 }
51710
51711
51712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51713   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51714   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51715
51716   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51717   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51718   {
51719     try {
51720       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51721     } catch (std::out_of_range& e) {
51722       {
51723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51724       };
51725     } catch (std::exception& e) {
51726       {
51727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51728       };
51729     } catch (Dali::DaliException e) {
51730       {
51731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51732       };
51733     } catch (...) {
51734       {
51735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51736       };
51737     }
51738   }
51739
51740 }
51741
51742
51743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51744   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51745   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51746
51747   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51748   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51749   {
51750     try {
51751       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51752     } catch (std::out_of_range& e) {
51753       {
51754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51755       };
51756     } catch (std::exception& e) {
51757       {
51758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51759       };
51760     } catch (Dali::DaliException e) {
51761       {
51762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51763       };
51764     } catch (...) {
51765       {
51766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51767       };
51768     }
51769   }
51770
51771 }
51772
51773
51774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51775   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51776   Dali::PropertyNotification *arg2 = 0 ;
51777
51778   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51779   arg2 = (Dali::PropertyNotification *)jarg2;
51780   if (!arg2) {
51781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51782     return ;
51783   }
51784   {
51785     try {
51786       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(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_new_PropertyNotifySignal() {
51810   void * jresult ;
51811   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51812
51813   {
51814     try {
51815       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51816     } catch (std::out_of_range& e) {
51817       {
51818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51819       };
51820     } catch (std::exception& e) {
51821       {
51822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51823       };
51824     } catch (Dali::DaliException e) {
51825       {
51826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51827       };
51828     } catch (...) {
51829       {
51830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51831       };
51832     }
51833   }
51834
51835   jresult = (void *)result;
51836   return jresult;
51837 }
51838
51839
51840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51841   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51842
51843   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51844   {
51845     try {
51846       delete arg1;
51847     } catch (std::out_of_range& e) {
51848       {
51849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51850       };
51851     } catch (std::exception& e) {
51852       {
51853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51854       };
51855     } catch (Dali::DaliException e) {
51856       {
51857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51858       };
51859     } catch (...) {
51860       {
51861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51862       };
51863     }
51864   }
51865
51866 }
51867
51868
51869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51870   void * jresult ;
51871   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51872
51873   {
51874     try {
51875       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51876     } catch (std::out_of_range& e) {
51877       {
51878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51879       };
51880     } catch (std::exception& e) {
51881       {
51882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51883       };
51884     } catch (Dali::DaliException e) {
51885       {
51886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51887       };
51888     } catch (...) {
51889       {
51890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51891       };
51892     }
51893   }
51894
51895   jresult = (void *)result;
51896   return jresult;
51897 }
51898
51899
51900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51901   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51902
51903   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51904   {
51905     try {
51906       delete arg1;
51907     } catch (std::out_of_range& e) {
51908       {
51909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51910       };
51911     } catch (std::exception& e) {
51912       {
51913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51914       };
51915     } catch (Dali::DaliException e) {
51916       {
51917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51918       };
51919     } catch (...) {
51920       {
51921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51922       };
51923     }
51924   }
51925
51926 }
51927
51928
51929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51930   unsigned int jresult ;
51931   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51932   bool result;
51933
51934   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51935   {
51936     try {
51937       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);
51938     } catch (std::out_of_range& e) {
51939       {
51940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51941       };
51942     } catch (std::exception& e) {
51943       {
51944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51945       };
51946     } catch (Dali::DaliException e) {
51947       {
51948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51949       };
51950     } catch (...) {
51951       {
51952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51953       };
51954     }
51955   }
51956
51957   jresult = result;
51958   return jresult;
51959 }
51960
51961
51962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51963   unsigned long jresult ;
51964   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51965   std::size_t result;
51966
51967   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51968   {
51969     try {
51970       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);
51971     } catch (std::out_of_range& e) {
51972       {
51973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51974       };
51975     } catch (std::exception& e) {
51976       {
51977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51978       };
51979     } catch (Dali::DaliException e) {
51980       {
51981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51982       };
51983     } catch (...) {
51984       {
51985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51986       };
51987     }
51988   }
51989
51990   jresult = (unsigned long)result;
51991   return jresult;
51992 }
51993
51994
51995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51996   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51997   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51998
51999   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52000   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
52001   {
52002     try {
52003       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52004     } catch (std::out_of_range& e) {
52005       {
52006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52007       };
52008     } catch (std::exception& e) {
52009       {
52010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52011       };
52012     } catch (Dali::DaliException e) {
52013       {
52014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52015       };
52016     } catch (...) {
52017       {
52018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52019       };
52020     }
52021   }
52022
52023 }
52024
52025
52026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52027   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52028   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
52029
52030   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52031   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
52032   {
52033     try {
52034       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52035     } catch (std::out_of_range& e) {
52036       {
52037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52038       };
52039     } catch (std::exception& e) {
52040       {
52041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52042       };
52043     } catch (Dali::DaliException e) {
52044       {
52045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52046       };
52047     } catch (...) {
52048       {
52049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52050       };
52051     }
52052   }
52053
52054 }
52055
52056
52057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52058   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52059   Dali::Actor arg2 ;
52060   Dali::LongPressGesture *arg3 = 0 ;
52061   Dali::Actor *argp2 ;
52062
52063   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52064   argp2 = (Dali::Actor *)jarg2;
52065   if (!argp2) {
52066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52067     return ;
52068   }
52069   arg2 = *argp2;
52070   arg3 = (Dali::LongPressGesture *)jarg3;
52071   if (!arg3) {
52072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
52073     return ;
52074   }
52075   {
52076     try {
52077       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
52078     } catch (std::out_of_range& e) {
52079       {
52080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52081       };
52082     } catch (std::exception& e) {
52083       {
52084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52085       };
52086     } catch (Dali::DaliException e) {
52087       {
52088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52089       };
52090     } catch (...) {
52091       {
52092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52093       };
52094     }
52095   }
52096
52097 }
52098
52099
52100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
52101   void * jresult ;
52102   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
52103
52104   {
52105     try {
52106       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
52107     } catch (std::out_of_range& e) {
52108       {
52109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52110       };
52111     } catch (std::exception& e) {
52112       {
52113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52114       };
52115     } catch (Dali::DaliException e) {
52116       {
52117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52118       };
52119     } catch (...) {
52120       {
52121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52122       };
52123     }
52124   }
52125
52126   jresult = (void *)result;
52127   return jresult;
52128 }
52129
52130
52131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
52132   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52133
52134   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52135   {
52136     try {
52137       delete arg1;
52138     } catch (std::out_of_range& e) {
52139       {
52140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52141       };
52142     } catch (std::exception& e) {
52143       {
52144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52145       };
52146     } catch (Dali::DaliException e) {
52147       {
52148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52149       };
52150     } catch (...) {
52151       {
52152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52153       };
52154     }
52155   }
52156
52157 }
52158
52159
52160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
52161   unsigned int jresult ;
52162   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52163   bool result;
52164
52165   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52166   {
52167     try {
52168       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
52169     } catch (std::out_of_range& e) {
52170       {
52171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52172       };
52173     } catch (std::exception& e) {
52174       {
52175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52176       };
52177     } catch (Dali::DaliException e) {
52178       {
52179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52180       };
52181     } catch (...) {
52182       {
52183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52184       };
52185     }
52186   }
52187
52188   jresult = result;
52189   return jresult;
52190 }
52191
52192
52193 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
52194   unsigned long jresult ;
52195   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52196   std::size_t result;
52197
52198   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52199   {
52200     try {
52201       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
52202     } catch (std::out_of_range& e) {
52203       {
52204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52205       };
52206     } catch (std::exception& e) {
52207       {
52208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52209       };
52210     } catch (Dali::DaliException e) {
52211       {
52212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52213       };
52214     } catch (...) {
52215       {
52216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52217       };
52218     }
52219   }
52220
52221   jresult = (unsigned long)result;
52222   return jresult;
52223 }
52224
52225
52226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
52227   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52228   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
52229
52230   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52231   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
52232   {
52233     try {
52234       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52235     } catch (std::out_of_range& e) {
52236       {
52237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52238       };
52239     } catch (std::exception& e) {
52240       {
52241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52242       };
52243     } catch (Dali::DaliException e) {
52244       {
52245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52246       };
52247     } catch (...) {
52248       {
52249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52250       };
52251     }
52252   }
52253
52254 }
52255
52256
52257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
52258   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52259   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
52260
52261   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52262   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
52263   {
52264     try {
52265       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52266     } catch (std::out_of_range& e) {
52267       {
52268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52269       };
52270     } catch (std::exception& e) {
52271       {
52272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52273       };
52274     } catch (Dali::DaliException e) {
52275       {
52276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52277       };
52278     } catch (...) {
52279       {
52280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52281       };
52282     }
52283   }
52284
52285 }
52286
52287
52288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52289   unsigned int jresult ;
52290   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52291   Dali::Actor arg2 ;
52292   Dali::TouchData *arg3 = 0 ;
52293   Dali::Actor *argp2 ;
52294   bool result;
52295
52296   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52297   argp2 = (Dali::Actor *)jarg2;
52298   if (!argp2) {
52299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52300     return 0;
52301   }
52302   arg2 = *argp2;
52303   arg3 = (Dali::TouchData *)jarg3;
52304   if (!arg3) {
52305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
52306     return 0;
52307   }
52308   {
52309     try {
52310       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
52311     } catch (std::out_of_range& e) {
52312       {
52313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52314       };
52315     } catch (std::exception& e) {
52316       {
52317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52318       };
52319     } catch (Dali::DaliException e) {
52320       {
52321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52322       };
52323     } catch (...) {
52324       {
52325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52326       };
52327     }
52328   }
52329
52330   jresult = result;
52331   return jresult;
52332 }
52333
52334
52335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
52336   void * jresult ;
52337   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
52338
52339   {
52340     try {
52341       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
52342     } catch (std::out_of_range& e) {
52343       {
52344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52345       };
52346     } catch (std::exception& e) {
52347       {
52348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52349       };
52350     } catch (Dali::DaliException e) {
52351       {
52352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52353       };
52354     } catch (...) {
52355       {
52356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52357       };
52358     }
52359   }
52360
52361   jresult = (void *)result;
52362   return jresult;
52363 }
52364
52365
52366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
52367   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52368
52369   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52370   {
52371     try {
52372       delete arg1;
52373     } catch (std::out_of_range& e) {
52374       {
52375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52376       };
52377     } catch (std::exception& e) {
52378       {
52379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52380       };
52381     } catch (Dali::DaliException e) {
52382       {
52383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52384       };
52385     } catch (...) {
52386       {
52387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52388       };
52389     }
52390   }
52391
52392 }
52393
52394
52395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
52396   unsigned int jresult ;
52397   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52398   bool result;
52399
52400   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52401   {
52402     try {
52403       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);
52404     } catch (std::out_of_range& e) {
52405       {
52406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52407       };
52408     } catch (std::exception& e) {
52409       {
52410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52411       };
52412     } catch (Dali::DaliException e) {
52413       {
52414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52415       };
52416     } catch (...) {
52417       {
52418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52419       };
52420     }
52421   }
52422
52423   jresult = result;
52424   return jresult;
52425 }
52426
52427
52428 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
52429   unsigned long jresult ;
52430   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52431   std::size_t result;
52432
52433   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52434   {
52435     try {
52436       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);
52437     } catch (std::out_of_range& e) {
52438       {
52439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52440       };
52441     } catch (std::exception& e) {
52442       {
52443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52444       };
52445     } catch (Dali::DaliException e) {
52446       {
52447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52448       };
52449     } catch (...) {
52450       {
52451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52452       };
52453     }
52454   }
52455
52456   jresult = (unsigned long)result;
52457   return jresult;
52458 }
52459
52460
52461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
52462   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52463   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52464
52465   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52466   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52467   {
52468     try {
52469       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52470     } catch (std::out_of_range& e) {
52471       {
52472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52473       };
52474     } catch (std::exception& e) {
52475       {
52476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52477       };
52478     } catch (Dali::DaliException e) {
52479       {
52480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52481       };
52482     } catch (...) {
52483       {
52484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52485       };
52486     }
52487   }
52488
52489 }
52490
52491
52492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
52493   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52494   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52495
52496   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52497   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52498   {
52499     try {
52500       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52501     } catch (std::out_of_range& e) {
52502       {
52503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52504       };
52505     } catch (std::exception& e) {
52506       {
52507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52508       };
52509     } catch (Dali::DaliException e) {
52510       {
52511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52512       };
52513     } catch (...) {
52514       {
52515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52516       };
52517     }
52518   }
52519
52520 }
52521
52522
52523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52524   unsigned int jresult ;
52525   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52526   Dali::Actor arg2 ;
52527   Dali::HoverEvent *arg3 = 0 ;
52528   Dali::Actor *argp2 ;
52529   bool result;
52530
52531   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52532   argp2 = (Dali::Actor *)jarg2;
52533   if (!argp2) {
52534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52535     return 0;
52536   }
52537   arg2 = *argp2;
52538   arg3 = (Dali::HoverEvent *)jarg3;
52539   if (!arg3) {
52540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52541     return 0;
52542   }
52543   {
52544     try {
52545       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52546     } catch (std::out_of_range& e) {
52547       {
52548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52549       };
52550     } catch (std::exception& e) {
52551       {
52552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52553       };
52554     } catch (Dali::DaliException e) {
52555       {
52556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52557       };
52558     } catch (...) {
52559       {
52560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52561       };
52562     }
52563   }
52564
52565   jresult = result;
52566   return jresult;
52567 }
52568
52569
52570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52571   void * jresult ;
52572   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52573
52574   {
52575     try {
52576       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52577     } catch (std::out_of_range& e) {
52578       {
52579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52580       };
52581     } catch (std::exception& e) {
52582       {
52583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52584       };
52585     } catch (Dali::DaliException e) {
52586       {
52587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52588       };
52589     } catch (...) {
52590       {
52591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52592       };
52593     }
52594   }
52595
52596   jresult = (void *)result;
52597   return jresult;
52598 }
52599
52600
52601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52602   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52603
52604   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52605   {
52606     try {
52607       delete arg1;
52608     } catch (std::out_of_range& e) {
52609       {
52610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52611       };
52612     } catch (std::exception& e) {
52613       {
52614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52615       };
52616     } catch (Dali::DaliException e) {
52617       {
52618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52619       };
52620     } catch (...) {
52621       {
52622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52623       };
52624     }
52625   }
52626
52627 }
52628
52629
52630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52631   unsigned int jresult ;
52632   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52633   bool result;
52634
52635   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52636   {
52637     try {
52638       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);
52639     } catch (std::out_of_range& e) {
52640       {
52641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52642       };
52643     } catch (std::exception& e) {
52644       {
52645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52646       };
52647     } catch (Dali::DaliException e) {
52648       {
52649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52650       };
52651     } catch (...) {
52652       {
52653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52654       };
52655     }
52656   }
52657
52658   jresult = result;
52659   return jresult;
52660 }
52661
52662
52663 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52664   unsigned long jresult ;
52665   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52666   std::size_t result;
52667
52668   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52669   {
52670     try {
52671       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);
52672     } catch (std::out_of_range& e) {
52673       {
52674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52675       };
52676     } catch (std::exception& e) {
52677       {
52678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52679       };
52680     } catch (Dali::DaliException e) {
52681       {
52682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52683       };
52684     } catch (...) {
52685       {
52686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52687       };
52688     }
52689   }
52690
52691   jresult = (unsigned long)result;
52692   return jresult;
52693 }
52694
52695
52696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52697   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52698   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52699
52700   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52701   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52702   {
52703     try {
52704       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52705     } catch (std::out_of_range& e) {
52706       {
52707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52708       };
52709     } catch (std::exception& e) {
52710       {
52711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52712       };
52713     } catch (Dali::DaliException e) {
52714       {
52715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52716       };
52717     } catch (...) {
52718       {
52719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52720       };
52721     }
52722   }
52723
52724 }
52725
52726
52727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52728   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52729   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52730
52731   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52732   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52733   {
52734     try {
52735       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52736     } catch (std::out_of_range& e) {
52737       {
52738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52739       };
52740     } catch (std::exception& e) {
52741       {
52742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52743       };
52744     } catch (Dali::DaliException e) {
52745       {
52746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52747       };
52748     } catch (...) {
52749       {
52750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52751       };
52752     }
52753   }
52754
52755 }
52756
52757
52758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52759   unsigned int jresult ;
52760   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52761   Dali::Actor arg2 ;
52762   Dali::WheelEvent *arg3 = 0 ;
52763   Dali::Actor *argp2 ;
52764   bool result;
52765
52766   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52767   argp2 = (Dali::Actor *)jarg2;
52768   if (!argp2) {
52769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52770     return 0;
52771   }
52772   arg2 = *argp2;
52773   arg3 = (Dali::WheelEvent *)jarg3;
52774   if (!arg3) {
52775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52776     return 0;
52777   }
52778   {
52779     try {
52780       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52781     } catch (std::out_of_range& e) {
52782       {
52783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52784       };
52785     } catch (std::exception& e) {
52786       {
52787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52788       };
52789     } catch (Dali::DaliException e) {
52790       {
52791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52792       };
52793     } catch (...) {
52794       {
52795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52796       };
52797     }
52798   }
52799
52800   jresult = result;
52801   return jresult;
52802 }
52803
52804
52805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52806   void * jresult ;
52807   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52808
52809   {
52810     try {
52811       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52812     } catch (std::out_of_range& e) {
52813       {
52814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52815       };
52816     } catch (std::exception& e) {
52817       {
52818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52819       };
52820     } catch (Dali::DaliException e) {
52821       {
52822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52823       };
52824     } catch (...) {
52825       {
52826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52827       };
52828     }
52829   }
52830
52831   jresult = (void *)result;
52832   return jresult;
52833 }
52834
52835
52836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52837   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52838
52839   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52840   {
52841     try {
52842       delete arg1;
52843     } catch (std::out_of_range& e) {
52844       {
52845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52846       };
52847     } catch (std::exception& e) {
52848       {
52849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52850       };
52851     } catch (Dali::DaliException e) {
52852       {
52853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52854       };
52855     } catch (...) {
52856       {
52857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52858       };
52859     }
52860   }
52861
52862 }
52863
52864
52865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52866   unsigned int jresult ;
52867   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52868   bool result;
52869
52870   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52871   {
52872     try {
52873       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52874     } catch (std::out_of_range& e) {
52875       {
52876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52877       };
52878     } catch (std::exception& e) {
52879       {
52880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52881       };
52882     } catch (Dali::DaliException e) {
52883       {
52884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52885       };
52886     } catch (...) {
52887       {
52888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52889       };
52890     }
52891   }
52892
52893   jresult = result;
52894   return jresult;
52895 }
52896
52897
52898 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52899   unsigned long jresult ;
52900   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52901   std::size_t result;
52902
52903   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52904   {
52905     try {
52906       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52907     } catch (std::out_of_range& e) {
52908       {
52909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52910       };
52911     } catch (std::exception& e) {
52912       {
52913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52914       };
52915     } catch (Dali::DaliException e) {
52916       {
52917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52918       };
52919     } catch (...) {
52920       {
52921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52922       };
52923     }
52924   }
52925
52926   jresult = (unsigned long)result;
52927   return jresult;
52928 }
52929
52930
52931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52932   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52933   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52934
52935   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52936   arg2 = (void (*)(Dali::Actor))jarg2;
52937   {
52938     try {
52939       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52940     } catch (std::out_of_range& e) {
52941       {
52942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52943       };
52944     } catch (std::exception& e) {
52945       {
52946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52947       };
52948     } catch (Dali::DaliException e) {
52949       {
52950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52951       };
52952     } catch (...) {
52953       {
52954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52955       };
52956     }
52957   }
52958
52959 }
52960
52961
52962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52963   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52964   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52965
52966   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52967   arg2 = (void (*)(Dali::Actor))jarg2;
52968   {
52969     try {
52970       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52971     } catch (std::out_of_range& e) {
52972       {
52973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52974       };
52975     } catch (std::exception& e) {
52976       {
52977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52978       };
52979     } catch (Dali::DaliException e) {
52980       {
52981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52982       };
52983     } catch (...) {
52984       {
52985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52986       };
52987     }
52988   }
52989
52990 }
52991
52992
52993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52994   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52995   Dali::Actor arg2 ;
52996   Dali::Actor *argp2 ;
52997
52998   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52999   argp2 = (Dali::Actor *)jarg2;
53000   if (!argp2) {
53001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53002     return ;
53003   }
53004   arg2 = *argp2;
53005   {
53006     try {
53007       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
53008     } catch (std::out_of_range& e) {
53009       {
53010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53011       };
53012     } catch (std::exception& e) {
53013       {
53014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53015       };
53016     } catch (Dali::DaliException e) {
53017       {
53018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53019       };
53020     } catch (...) {
53021       {
53022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53023       };
53024     }
53025   }
53026
53027 }
53028
53029
53030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
53031   void * jresult ;
53032   Dali::Signal< void (Dali::Actor) > *result = 0 ;
53033
53034   {
53035     try {
53036       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
53037     } catch (std::out_of_range& e) {
53038       {
53039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53040       };
53041     } catch (std::exception& e) {
53042       {
53043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53044       };
53045     } catch (Dali::DaliException e) {
53046       {
53047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53048       };
53049     } catch (...) {
53050       {
53051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53052       };
53053     }
53054   }
53055
53056   jresult = (void *)result;
53057   return jresult;
53058 }
53059
53060
53061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
53062   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
53063
53064   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
53065   {
53066     try {
53067       delete arg1;
53068     } catch (std::out_of_range& e) {
53069       {
53070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53071       };
53072     } catch (std::exception& e) {
53073       {
53074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53075       };
53076     } catch (Dali::DaliException e) {
53077       {
53078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53079       };
53080     } catch (...) {
53081       {
53082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53083       };
53084     }
53085   }
53086
53087 }
53088
53089
53090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
53091   unsigned int jresult ;
53092   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53093   bool result;
53094
53095   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53096   {
53097     try {
53098       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
53099     } catch (std::out_of_range& e) {
53100       {
53101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53102       };
53103     } catch (std::exception& e) {
53104       {
53105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53106       };
53107     } catch (Dali::DaliException e) {
53108       {
53109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53110       };
53111     } catch (...) {
53112       {
53113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53114       };
53115     }
53116   }
53117
53118   jresult = result;
53119   return jresult;
53120 }
53121
53122
53123 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
53124   unsigned long jresult ;
53125   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53126   std::size_t result;
53127
53128   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53129   {
53130     try {
53131       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
53132     } catch (std::out_of_range& e) {
53133       {
53134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53135       };
53136     } catch (std::exception& e) {
53137       {
53138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53139       };
53140     } catch (Dali::DaliException e) {
53141       {
53142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53143       };
53144     } catch (...) {
53145       {
53146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53147       };
53148     }
53149   }
53150
53151   jresult = (unsigned long)result;
53152   return jresult;
53153 }
53154
53155
53156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
53157   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53158   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
53159
53160   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53161   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
53162   {
53163     try {
53164       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53165     } catch (std::out_of_range& e) {
53166       {
53167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53168       };
53169     } catch (std::exception& e) {
53170       {
53171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53172       };
53173     } catch (Dali::DaliException e) {
53174       {
53175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53176       };
53177     } catch (...) {
53178       {
53179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53180       };
53181     }
53182   }
53183
53184 }
53185
53186
53187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
53188   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53189   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
53190
53191   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53192   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
53193   {
53194     try {
53195       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53196     } catch (std::out_of_range& e) {
53197       {
53198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53199       };
53200     } catch (std::exception& e) {
53201       {
53202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53203       };
53204     } catch (Dali::DaliException e) {
53205       {
53206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53207       };
53208     } catch (...) {
53209       {
53210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53211       };
53212     }
53213   }
53214
53215 }
53216
53217
53218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
53219   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53220   Dali::KeyEvent *arg2 = 0 ;
53221
53222   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53223   arg2 = (Dali::KeyEvent *)jarg2;
53224   if (!arg2) {
53225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
53226     return ;
53227   }
53228   {
53229     try {
53230       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
53231     } catch (std::out_of_range& e) {
53232       {
53233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53234       };
53235     } catch (std::exception& e) {
53236       {
53237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53238       };
53239     } catch (Dali::DaliException e) {
53240       {
53241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53242       };
53243     } catch (...) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53246       };
53247     }
53248   }
53249
53250 }
53251
53252
53253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
53254   void * jresult ;
53255   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
53256
53257   {
53258     try {
53259       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
53260     } catch (std::out_of_range& e) {
53261       {
53262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53263       };
53264     } catch (std::exception& e) {
53265       {
53266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53267       };
53268     } catch (Dali::DaliException e) {
53269       {
53270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53271       };
53272     } catch (...) {
53273       {
53274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53275       };
53276     }
53277   }
53278
53279   jresult = (void *)result;
53280   return jresult;
53281 }
53282
53283
53284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
53285   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53286
53287   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53288   {
53289     try {
53290       delete arg1;
53291     } catch (std::out_of_range& e) {
53292       {
53293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53294       };
53295     } catch (std::exception& e) {
53296       {
53297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53298       };
53299     } catch (Dali::DaliException e) {
53300       {
53301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53302       };
53303     } catch (...) {
53304       {
53305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53306       };
53307     }
53308   }
53309
53310 }
53311
53312
53313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
53314   unsigned int jresult ;
53315   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53316   bool result;
53317
53318   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53319   {
53320     try {
53321       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
53322     } catch (std::out_of_range& e) {
53323       {
53324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53325       };
53326     } catch (std::exception& e) {
53327       {
53328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53329       };
53330     } catch (Dali::DaliException e) {
53331       {
53332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53333       };
53334     } catch (...) {
53335       {
53336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53337       };
53338     }
53339   }
53340
53341   jresult = result;
53342   return jresult;
53343 }
53344
53345
53346 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
53347   unsigned long jresult ;
53348   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53349   std::size_t result;
53350
53351   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53352   {
53353     try {
53354       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
53355     } catch (std::out_of_range& e) {
53356       {
53357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53358       };
53359     } catch (std::exception& e) {
53360       {
53361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53362       };
53363     } catch (Dali::DaliException e) {
53364       {
53365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53366       };
53367     } catch (...) {
53368       {
53369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53370       };
53371     }
53372   }
53373
53374   jresult = (unsigned long)result;
53375   return jresult;
53376 }
53377
53378
53379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
53380   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53381   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
53382
53383   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53384   arg2 = (void (*)(Dali::TouchData const &))jarg2;
53385   {
53386     try {
53387       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53388     } catch (std::out_of_range& e) {
53389       {
53390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53391       };
53392     } catch (std::exception& e) {
53393       {
53394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53395       };
53396     } catch (Dali::DaliException e) {
53397       {
53398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53399       };
53400     } catch (...) {
53401       {
53402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53403       };
53404     }
53405   }
53406
53407 }
53408
53409
53410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
53411   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53412   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
53413
53414   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53415   arg2 = (void (*)(Dali::TouchData const &))jarg2;
53416   {
53417     try {
53418       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53419     } catch (std::out_of_range& e) {
53420       {
53421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53422       };
53423     } catch (std::exception& e) {
53424       {
53425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53426       };
53427     } catch (Dali::DaliException e) {
53428       {
53429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53430       };
53431     } catch (...) {
53432       {
53433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53434       };
53435     }
53436   }
53437
53438 }
53439
53440
53441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
53442   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53443   Dali::TouchData *arg2 = 0 ;
53444
53445   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53446   arg2 = (Dali::TouchData *)jarg2;
53447   if (!arg2) {
53448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
53449     return ;
53450   }
53451   {
53452     try {
53453       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
53454     } catch (std::out_of_range& e) {
53455       {
53456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53457       };
53458     } catch (std::exception& e) {
53459       {
53460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53461       };
53462     } catch (Dali::DaliException e) {
53463       {
53464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53465       };
53466     } catch (...) {
53467       {
53468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53469       };
53470     }
53471   }
53472
53473 }
53474
53475
53476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
53477   void * jresult ;
53478   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
53479
53480   {
53481     try {
53482       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
53483     } catch (std::out_of_range& e) {
53484       {
53485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53486       };
53487     } catch (std::exception& e) {
53488       {
53489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53490       };
53491     } catch (Dali::DaliException e) {
53492       {
53493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53494       };
53495     } catch (...) {
53496       {
53497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53498       };
53499     }
53500   }
53501
53502   jresult = (void *)result;
53503   return jresult;
53504 }
53505
53506
53507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
53508   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53509
53510   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53511   {
53512     try {
53513       delete arg1;
53514     } catch (std::out_of_range& e) {
53515       {
53516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53517       };
53518     } catch (std::exception& e) {
53519       {
53520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53521       };
53522     } catch (Dali::DaliException e) {
53523       {
53524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53525       };
53526     } catch (...) {
53527       {
53528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53529       };
53530     }
53531   }
53532
53533 }
53534
53535
53536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53537   unsigned int jresult ;
53538   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53539   bool result;
53540
53541   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53542   {
53543     try {
53544       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53545     } catch (std::out_of_range& e) {
53546       {
53547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53548       };
53549     } catch (std::exception& e) {
53550       {
53551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53552       };
53553     } catch (Dali::DaliException e) {
53554       {
53555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53556       };
53557     } catch (...) {
53558       {
53559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53560       };
53561     }
53562   }
53563
53564   jresult = result;
53565   return jresult;
53566 }
53567
53568
53569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53570   unsigned long jresult ;
53571   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53572   std::size_t result;
53573
53574   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53575   {
53576     try {
53577       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53578     } catch (std::out_of_range& e) {
53579       {
53580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53581       };
53582     } catch (std::exception& e) {
53583       {
53584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53585       };
53586     } catch (Dali::DaliException e) {
53587       {
53588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53589       };
53590     } catch (...) {
53591       {
53592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53593       };
53594     }
53595   }
53596
53597   jresult = (unsigned long)result;
53598   return jresult;
53599 }
53600
53601
53602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53603   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53604   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53605
53606   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53607   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53608   {
53609     try {
53610       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53611     } catch (std::out_of_range& e) {
53612       {
53613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53614       };
53615     } catch (std::exception& e) {
53616       {
53617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53618       };
53619     } catch (Dali::DaliException e) {
53620       {
53621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53622       };
53623     } catch (...) {
53624       {
53625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53626       };
53627     }
53628   }
53629
53630 }
53631
53632
53633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53634   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53635   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53636
53637   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53638   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53639   {
53640     try {
53641       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53642     } catch (std::out_of_range& e) {
53643       {
53644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53645       };
53646     } catch (std::exception& e) {
53647       {
53648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53649       };
53650     } catch (Dali::DaliException e) {
53651       {
53652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53653       };
53654     } catch (...) {
53655       {
53656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53657       };
53658     }
53659   }
53660
53661 }
53662
53663
53664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53665   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53666   Dali::WheelEvent *arg2 = 0 ;
53667
53668   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53669   arg2 = (Dali::WheelEvent *)jarg2;
53670   if (!arg2) {
53671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53672     return ;
53673   }
53674   {
53675     try {
53676       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
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 void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53700   void * jresult ;
53701   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53702
53703   {
53704     try {
53705       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53706     } catch (std::out_of_range& e) {
53707       {
53708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53709       };
53710     } catch (std::exception& e) {
53711       {
53712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53713       };
53714     } catch (Dali::DaliException e) {
53715       {
53716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53717       };
53718     } catch (...) {
53719       {
53720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53721       };
53722     }
53723   }
53724
53725   jresult = (void *)result;
53726   return jresult;
53727 }
53728
53729
53730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53731   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53732
53733   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53734   {
53735     try {
53736       delete arg1;
53737     } catch (std::out_of_range& e) {
53738       {
53739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53740       };
53741     } catch (std::exception& e) {
53742       {
53743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53744       };
53745     } catch (Dali::DaliException e) {
53746       {
53747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53748       };
53749     } catch (...) {
53750       {
53751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53752       };
53753     }
53754   }
53755
53756 }
53757
53758
53759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53760   void * jresult ;
53761   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53762
53763   {
53764     try {
53765       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53766     } catch (std::out_of_range& e) {
53767       {
53768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53769       };
53770     } catch (std::exception& e) {
53771       {
53772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53773       };
53774     } catch (Dali::DaliException e) {
53775       {
53776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53777       };
53778     } catch (...) {
53779       {
53780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53781       };
53782     }
53783   }
53784
53785   jresult = (void *)result;
53786   return jresult;
53787 }
53788
53789
53790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53791   void * jresult ;
53792   Dali::Radian arg1 ;
53793   Dali::Radian arg2 ;
53794   Dali::Radian *argp1 ;
53795   Dali::Radian *argp2 ;
53796   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53797
53798   argp1 = (Dali::Radian *)jarg1;
53799   if (!argp1) {
53800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53801     return 0;
53802   }
53803   arg1 = *argp1;
53804   argp2 = (Dali::Radian *)jarg2;
53805   if (!argp2) {
53806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53807     return 0;
53808   }
53809   arg2 = *argp2;
53810   {
53811     try {
53812       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53813     } catch (std::out_of_range& e) {
53814       {
53815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53816       };
53817     } catch (std::exception& e) {
53818       {
53819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53820       };
53821     } catch (Dali::DaliException e) {
53822       {
53823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53824       };
53825     } catch (...) {
53826       {
53827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53828       };
53829     }
53830   }
53831
53832   jresult = (void *)result;
53833   return jresult;
53834 }
53835
53836
53837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53838   void * jresult ;
53839   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53840   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53841
53842   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53843   if (!arg1) {
53844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53845     return 0;
53846   }
53847   {
53848     try {
53849       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53850     } catch (std::out_of_range& e) {
53851       {
53852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53853       };
53854     } catch (std::exception& e) {
53855       {
53856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53857       };
53858     } catch (Dali::DaliException e) {
53859       {
53860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53861       };
53862     } catch (...) {
53863       {
53864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53865       };
53866     }
53867   }
53868
53869   jresult = (void *)result;
53870   return jresult;
53871 }
53872
53873
53874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53875   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53876   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53877
53878   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53879   arg2 = (Dali::Radian *)jarg2;
53880   if (arg1) (arg1)->first = *arg2;
53881 }
53882
53883
53884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53885   void * jresult ;
53886   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53887   Dali::Radian *result = 0 ;
53888
53889   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53890   result = (Dali::Radian *)& ((arg1)->first);
53891   jresult = (void *)result;
53892   return jresult;
53893 }
53894
53895
53896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53897   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53898   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53899
53900   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53901   arg2 = (Dali::Radian *)jarg2;
53902   if (arg1) (arg1)->second = *arg2;
53903 }
53904
53905
53906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53907   void * jresult ;
53908   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53909   Dali::Radian *result = 0 ;
53910
53911   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53912   result = (Dali::Radian *)& ((arg1)->second);
53913   jresult = (void *)result;
53914   return jresult;
53915 }
53916
53917
53918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53919   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53920
53921   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53922   {
53923     try {
53924       delete arg1;
53925     } catch (std::out_of_range& e) {
53926       {
53927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53928       };
53929     } catch (std::exception& e) {
53930       {
53931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53932       };
53933     } catch (Dali::DaliException e) {
53934       {
53935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53936       };
53937     } catch (...) {
53938       {
53939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53940       };
53941     }
53942   }
53943
53944 }
53945
53946
53947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53948   unsigned int jresult ;
53949   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53950   bool result;
53951
53952   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53953   {
53954     try {
53955       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);
53956     } catch (std::out_of_range& e) {
53957       {
53958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53959       };
53960     } catch (std::exception& e) {
53961       {
53962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53963       };
53964     } catch (Dali::DaliException e) {
53965       {
53966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53967       };
53968     } catch (...) {
53969       {
53970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53971       };
53972     }
53973   }
53974
53975   jresult = result;
53976   return jresult;
53977 }
53978
53979
53980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53981   unsigned long jresult ;
53982   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53983   std::size_t result;
53984
53985   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53986   {
53987     try {
53988       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);
53989     } catch (std::out_of_range& e) {
53990       {
53991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53992       };
53993     } catch (std::exception& e) {
53994       {
53995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53996       };
53997     } catch (Dali::DaliException e) {
53998       {
53999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54000       };
54001     } catch (...) {
54002       {
54003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54004       };
54005     }
54006   }
54007
54008   jresult = (unsigned long)result;
54009   return jresult;
54010 }
54011
54012
54013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54014   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54015   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
54016
54017   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54018   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
54019   {
54020     try {
54021       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54022     } catch (std::out_of_range& e) {
54023       {
54024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54025       };
54026     } catch (std::exception& e) {
54027       {
54028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54029       };
54030     } catch (Dali::DaliException e) {
54031       {
54032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54033       };
54034     } catch (...) {
54035       {
54036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54037       };
54038     }
54039   }
54040
54041 }
54042
54043
54044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54045   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54046   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
54047
54048   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54049   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
54050   {
54051     try {
54052       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54053     } catch (std::out_of_range& e) {
54054       {
54055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54056       };
54057     } catch (std::exception& e) {
54058       {
54059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54060       };
54061     } catch (Dali::DaliException e) {
54062       {
54063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54064       };
54065     } catch (...) {
54066       {
54067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54068       };
54069     }
54070   }
54071
54072 }
54073
54074
54075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54076   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54077   Dali::Actor arg2 ;
54078   Dali::PanGesture *arg3 = 0 ;
54079   Dali::Actor *argp2 ;
54080
54081   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54082   argp2 = (Dali::Actor *)jarg2;
54083   if (!argp2) {
54084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54085     return ;
54086   }
54087   arg2 = *argp2;
54088   arg3 = (Dali::PanGesture *)jarg3;
54089   if (!arg3) {
54090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
54091     return ;
54092   }
54093   {
54094     try {
54095       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
54096     } catch (std::out_of_range& e) {
54097       {
54098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54099       };
54100     } catch (std::exception& e) {
54101       {
54102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54103       };
54104     } catch (Dali::DaliException e) {
54105       {
54106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54107       };
54108     } catch (...) {
54109       {
54110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54111       };
54112     }
54113   }
54114
54115 }
54116
54117
54118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
54119   void * jresult ;
54120   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
54121
54122   {
54123     try {
54124       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
54125     } catch (std::out_of_range& e) {
54126       {
54127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54128       };
54129     } catch (std::exception& e) {
54130       {
54131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54132       };
54133     } catch (Dali::DaliException e) {
54134       {
54135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54136       };
54137     } catch (...) {
54138       {
54139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54140       };
54141     }
54142   }
54143
54144   jresult = (void *)result;
54145   return jresult;
54146 }
54147
54148
54149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
54150   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54151
54152   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54153   {
54154     try {
54155       delete arg1;
54156     } catch (std::out_of_range& e) {
54157       {
54158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54159       };
54160     } catch (std::exception& e) {
54161       {
54162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54163       };
54164     } catch (Dali::DaliException e) {
54165       {
54166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54167       };
54168     } catch (...) {
54169       {
54170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54171       };
54172     }
54173   }
54174
54175 }
54176
54177
54178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
54179   unsigned int jresult ;
54180   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54181   bool result;
54182
54183   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54184   {
54185     try {
54186       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);
54187     } catch (std::out_of_range& e) {
54188       {
54189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54190       };
54191     } catch (std::exception& e) {
54192       {
54193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54194       };
54195     } catch (Dali::DaliException e) {
54196       {
54197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54198       };
54199     } catch (...) {
54200       {
54201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54202       };
54203     }
54204   }
54205
54206   jresult = result;
54207   return jresult;
54208 }
54209
54210
54211 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54212   unsigned long jresult ;
54213   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54214   std::size_t result;
54215
54216   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54217   {
54218     try {
54219       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);
54220     } catch (std::out_of_range& e) {
54221       {
54222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54223       };
54224     } catch (std::exception& e) {
54225       {
54226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54227       };
54228     } catch (Dali::DaliException e) {
54229       {
54230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54231       };
54232     } catch (...) {
54233       {
54234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54235       };
54236     }
54237   }
54238
54239   jresult = (unsigned long)result;
54240   return jresult;
54241 }
54242
54243
54244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54245   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54246   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54247
54248   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54249   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54250   {
54251     try {
54252       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54253     } catch (std::out_of_range& e) {
54254       {
54255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54256       };
54257     } catch (std::exception& e) {
54258       {
54259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54260       };
54261     } catch (Dali::DaliException e) {
54262       {
54263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54264       };
54265     } catch (...) {
54266       {
54267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54268       };
54269     }
54270   }
54271
54272 }
54273
54274
54275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54276   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54277   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54278
54279   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54280   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54281   {
54282     try {
54283       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54284     } catch (std::out_of_range& e) {
54285       {
54286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54287       };
54288     } catch (std::exception& e) {
54289       {
54290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54291       };
54292     } catch (Dali::DaliException e) {
54293       {
54294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54295       };
54296     } catch (...) {
54297       {
54298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54299       };
54300     }
54301   }
54302
54303 }
54304
54305
54306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54307   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54308   Dali::Actor arg2 ;
54309   Dali::PinchGesture *arg3 = 0 ;
54310   Dali::Actor *argp2 ;
54311
54312   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54313   argp2 = (Dali::Actor *)jarg2;
54314   if (!argp2) {
54315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54316     return ;
54317   }
54318   arg2 = *argp2;
54319   arg3 = (Dali::PinchGesture *)jarg3;
54320   if (!arg3) {
54321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
54322     return ;
54323   }
54324   {
54325     try {
54326       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
54327     } catch (std::out_of_range& e) {
54328       {
54329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54330       };
54331     } catch (std::exception& e) {
54332       {
54333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54334       };
54335     } catch (Dali::DaliException e) {
54336       {
54337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54338       };
54339     } catch (...) {
54340       {
54341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54342       };
54343     }
54344   }
54345
54346 }
54347
54348
54349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
54350   void * jresult ;
54351   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
54352
54353   {
54354     try {
54355       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
54356     } catch (std::out_of_range& e) {
54357       {
54358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54359       };
54360     } catch (std::exception& e) {
54361       {
54362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54363       };
54364     } catch (Dali::DaliException e) {
54365       {
54366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54367       };
54368     } catch (...) {
54369       {
54370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54371       };
54372     }
54373   }
54374
54375   jresult = (void *)result;
54376   return jresult;
54377 }
54378
54379
54380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
54381   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54382
54383   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54384   {
54385     try {
54386       delete arg1;
54387     } catch (std::out_of_range& e) {
54388       {
54389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54390       };
54391     } catch (std::exception& e) {
54392       {
54393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54394       };
54395     } catch (Dali::DaliException e) {
54396       {
54397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54398       };
54399     } catch (...) {
54400       {
54401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54402       };
54403     }
54404   }
54405
54406 }
54407
54408
54409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
54410   unsigned int jresult ;
54411   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54412   bool result;
54413
54414   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54415   {
54416     try {
54417       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);
54418     } catch (std::out_of_range& e) {
54419       {
54420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54421       };
54422     } catch (std::exception& e) {
54423       {
54424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54425       };
54426     } catch (Dali::DaliException e) {
54427       {
54428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54429       };
54430     } catch (...) {
54431       {
54432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54433       };
54434     }
54435   }
54436
54437   jresult = result;
54438   return jresult;
54439 }
54440
54441
54442 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54443   unsigned long jresult ;
54444   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54445   std::size_t result;
54446
54447   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54448   {
54449     try {
54450       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);
54451     } catch (std::out_of_range& e) {
54452       {
54453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54454       };
54455     } catch (std::exception& e) {
54456       {
54457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54458       };
54459     } catch (Dali::DaliException e) {
54460       {
54461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54462       };
54463     } catch (...) {
54464       {
54465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54466       };
54467     }
54468   }
54469
54470   jresult = (unsigned long)result;
54471   return jresult;
54472 }
54473
54474
54475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54476   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54477   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54478
54479   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54480   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54481   {
54482     try {
54483       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54484     } catch (std::out_of_range& e) {
54485       {
54486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54487       };
54488     } catch (std::exception& e) {
54489       {
54490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54491       };
54492     } catch (Dali::DaliException e) {
54493       {
54494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54495       };
54496     } catch (...) {
54497       {
54498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54499       };
54500     }
54501   }
54502
54503 }
54504
54505
54506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54507   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54508   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54509
54510   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54511   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54512   {
54513     try {
54514       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54515     } catch (std::out_of_range& e) {
54516       {
54517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54518       };
54519     } catch (std::exception& e) {
54520       {
54521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54522       };
54523     } catch (Dali::DaliException e) {
54524       {
54525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54526       };
54527     } catch (...) {
54528       {
54529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54530       };
54531     }
54532   }
54533
54534 }
54535
54536
54537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54538   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54539   Dali::Actor arg2 ;
54540   Dali::TapGesture *arg3 = 0 ;
54541   Dali::Actor *argp2 ;
54542
54543   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54544   argp2 = (Dali::Actor *)jarg2;
54545   if (!argp2) {
54546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54547     return ;
54548   }
54549   arg2 = *argp2;
54550   arg3 = (Dali::TapGesture *)jarg3;
54551   if (!arg3) {
54552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54553     return ;
54554   }
54555   {
54556     try {
54557       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54558     } catch (std::out_of_range& e) {
54559       {
54560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54561       };
54562     } catch (std::exception& e) {
54563       {
54564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54565       };
54566     } catch (Dali::DaliException e) {
54567       {
54568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54569       };
54570     } catch (...) {
54571       {
54572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54573       };
54574     }
54575   }
54576
54577 }
54578
54579
54580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54581   void * jresult ;
54582   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54583
54584   {
54585     try {
54586       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54587     } catch (std::out_of_range& e) {
54588       {
54589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54590       };
54591     } catch (std::exception& e) {
54592       {
54593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54594       };
54595     } catch (Dali::DaliException e) {
54596       {
54597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54598       };
54599     } catch (...) {
54600       {
54601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54602       };
54603     }
54604   }
54605
54606   jresult = (void *)result;
54607   return jresult;
54608 }
54609
54610
54611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54612   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54613
54614   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54615   {
54616     try {
54617       delete arg1;
54618     } catch (std::out_of_range& e) {
54619       {
54620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54621       };
54622     } catch (std::exception& e) {
54623       {
54624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54625       };
54626     } catch (Dali::DaliException e) {
54627       {
54628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54629       };
54630     } catch (...) {
54631       {
54632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54633       };
54634     }
54635   }
54636
54637 }
54638
54639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54640   unsigned int jresult ;
54641   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54642   bool result = false;
54643
54644   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54645   {
54646     try {
54647       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);
54648     } catch (std::out_of_range& e) {
54649       {
54650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54651       };
54652     } catch (std::exception& e) {
54653       {
54654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54655       };
54656     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54657   }
54658   jresult = result;
54659   return jresult;
54660 }
54661
54662 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54663   unsigned long jresult ;
54664   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54665   std::size_t result = 0;
54666
54667   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54668   {
54669     try {
54670       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);
54671     } catch (std::out_of_range& e) {
54672       {
54673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54674       };
54675     } catch (std::exception& e) {
54676       {
54677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54678       };
54679     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54680   }
54681   jresult = (unsigned long)result;
54682   return jresult;
54683 }
54684
54685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54686   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54687   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54688
54689   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54690   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54691   {
54692     try {
54693       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54694     } catch (std::out_of_range& e) {
54695       {
54696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54697       };
54698     } catch (std::exception& e) {
54699       {
54700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54701       };
54702     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54703   }
54704 }
54705
54706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54707   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54708   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54709
54710   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54711   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54712   {
54713     try {
54714       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54715     } catch (std::out_of_range& e) {
54716       {
54717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54718       };
54719     } catch (std::exception& e) {
54720       {
54721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54722       };
54723     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54724   }
54725 }
54726
54727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54728   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54729   Dali::Actor arg2 ;
54730   //bool arg3 ;
54731   Dali::LayoutDirection::Type arg4 ;
54732   Dali::Actor *argp2 ;
54733
54734   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54735   argp2 = (Dali::Actor *)jarg2;
54736   if (!argp2) {
54737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54738     return ;
54739   }
54740   arg2 = *argp2;
54741   //arg3 = jarg3 ? true : false;
54742   arg4 = (Dali::LayoutDirection::Type)jarg4;
54743   {
54744     try {
54745       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54746     } catch (std::out_of_range& e) {
54747       {
54748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54749       };
54750     } catch (std::exception& e) {
54751       {
54752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54753       };
54754     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54755   }
54756 }
54757
54758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54759   void * jresult ;
54760   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54761
54762   {
54763     try {
54764       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54765     } catch (std::out_of_range& e) {
54766       {
54767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54768       };
54769     } catch (std::exception& e) {
54770       {
54771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54772       };
54773     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54774   }
54775   jresult = (void *)result;
54776   return jresult;
54777 }
54778
54779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54780   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54781
54782   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54783   {
54784     try {
54785       delete arg1;
54786     } catch (std::out_of_range& e) {
54787       {
54788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54789       };
54790     } catch (std::exception& e) {
54791       {
54792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54793       };
54794     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54795   }
54796 }
54797
54798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54799   unsigned int jresult ;
54800   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54801   bool result;
54802
54803   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54804   {
54805     try {
54806       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);
54807     } catch (std::out_of_range& e) {
54808       {
54809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54810       };
54811     } catch (std::exception& e) {
54812       {
54813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54814       };
54815     } catch (Dali::DaliException e) {
54816       {
54817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54818       };
54819     } catch (...) {
54820       {
54821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54822       };
54823     }
54824   }
54825
54826   jresult = result;
54827   return jresult;
54828 }
54829
54830
54831 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54832   unsigned long jresult ;
54833   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54834   std::size_t result;
54835
54836   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54837   {
54838     try {
54839       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);
54840     } catch (std::out_of_range& e) {
54841       {
54842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54843       };
54844     } catch (std::exception& e) {
54845       {
54846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54847       };
54848     } catch (Dali::DaliException e) {
54849       {
54850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54851       };
54852     } catch (...) {
54853       {
54854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54855       };
54856     }
54857   }
54858
54859   jresult = (unsigned long)result;
54860   return jresult;
54861 }
54862
54863
54864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54865   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54866   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54867
54868   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54869   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54870   {
54871     try {
54872       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54873     } catch (std::out_of_range& e) {
54874       {
54875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54876       };
54877     } catch (std::exception& e) {
54878       {
54879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54880       };
54881     } catch (Dali::DaliException e) {
54882       {
54883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54884       };
54885     } catch (...) {
54886       {
54887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54888       };
54889     }
54890   }
54891
54892 }
54893
54894
54895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54896   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54897   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54898
54899   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54900   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54901   {
54902     try {
54903       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54904     } catch (std::out_of_range& e) {
54905       {
54906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54907       };
54908     } catch (std::exception& e) {
54909       {
54910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54911       };
54912     } catch (Dali::DaliException e) {
54913       {
54914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54915       };
54916     } catch (...) {
54917       {
54918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54919       };
54920     }
54921   }
54922
54923 }
54924
54925
54926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54927   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54928   Dali::Actor arg2 ;
54929   bool arg3 ;
54930   Dali::DevelActor::VisibilityChange::Type arg4 ;
54931   Dali::Actor *argp2 ;
54932
54933   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54934   argp2 = (Dali::Actor *)jarg2;
54935   if (!argp2) {
54936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54937     return ;
54938   }
54939   arg2 = *argp2;
54940   arg3 = jarg3 ? true : false;
54941   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54942   {
54943     try {
54944       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54945     } catch (std::out_of_range& e) {
54946       {
54947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54948       };
54949     } catch (std::exception& e) {
54950       {
54951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54952       };
54953     } catch (Dali::DaliException e) {
54954       {
54955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54956       };
54957     } catch (...) {
54958       {
54959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54960       };
54961     }
54962   }
54963
54964 }
54965
54966
54967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54968   void * jresult ;
54969   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54970
54971   {
54972     try {
54973       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54974     } catch (std::out_of_range& e) {
54975       {
54976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54977       };
54978     } catch (std::exception& e) {
54979       {
54980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54981       };
54982     } catch (Dali::DaliException e) {
54983       {
54984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54985       };
54986     } catch (...) {
54987       {
54988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54989       };
54990     }
54991   }
54992
54993   jresult = (void *)result;
54994   return jresult;
54995 }
54996
54997
54998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54999   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
55000
55001   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
55002   {
55003     try {
55004       delete arg1;
55005     } catch (std::out_of_range& e) {
55006       {
55007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55008       };
55009     } catch (std::exception& e) {
55010       {
55011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55012       };
55013     } catch (Dali::DaliException e) {
55014       {
55015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55016       };
55017     } catch (...) {
55018       {
55019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55020       };
55021     }
55022   }
55023
55024 }
55025
55026
55027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
55028   void * jresult ;
55029   Dali::Timer *result = 0 ;
55030
55031   {
55032     try {
55033       result = (Dali::Timer *)new Dali::Timer();
55034     } catch (std::out_of_range& e) {
55035       {
55036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55037       };
55038     } catch (std::exception& e) {
55039       {
55040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55041       };
55042     } catch (Dali::DaliException e) {
55043       {
55044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55045       };
55046     } catch (...) {
55047       {
55048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55049       };
55050     }
55051   }
55052
55053   jresult = (void *)result;
55054   return jresult;
55055 }
55056
55057
55058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
55059   void * jresult ;
55060   unsigned int arg1 ;
55061   Dali::Timer result;
55062
55063   arg1 = (unsigned int)jarg1;
55064   {
55065     try {
55066       result = Dali::Timer::New(arg1);
55067     } catch (std::out_of_range& e) {
55068       {
55069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55070       };
55071     } catch (std::exception& e) {
55072       {
55073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55074       };
55075     } catch (Dali::DaliException e) {
55076       {
55077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55078       };
55079     } catch (...) {
55080       {
55081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55082       };
55083     }
55084   }
55085
55086   jresult = new Dali::Timer((const Dali::Timer &)result);
55087   return jresult;
55088 }
55089
55090
55091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
55092   void * jresult ;
55093   Dali::Timer *arg1 = 0 ;
55094   Dali::Timer *result = 0 ;
55095
55096   arg1 = (Dali::Timer *)jarg1;
55097   if (!arg1) {
55098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
55099     return 0;
55100   }
55101   {
55102     try {
55103       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
55104     } catch (std::out_of_range& e) {
55105       {
55106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55107       };
55108     } catch (std::exception& e) {
55109       {
55110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55111       };
55112     } catch (Dali::DaliException e) {
55113       {
55114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55115       };
55116     } catch (...) {
55117       {
55118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55119       };
55120     }
55121   }
55122
55123   jresult = (void *)result;
55124   return jresult;
55125 }
55126
55127
55128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
55129   void * jresult ;
55130   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55131   Dali::Timer *arg2 = 0 ;
55132   Dali::Timer *result = 0 ;
55133
55134   arg1 = (Dali::Timer *)jarg1;
55135   arg2 = (Dali::Timer *)jarg2;
55136   if (!arg2) {
55137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
55138     return 0;
55139   }
55140   {
55141     try {
55142       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
55143     } catch (std::out_of_range& e) {
55144       {
55145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55146       };
55147     } catch (std::exception& e) {
55148       {
55149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55150       };
55151     } catch (Dali::DaliException e) {
55152       {
55153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55154       };
55155     } catch (...) {
55156       {
55157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55158       };
55159     }
55160   }
55161
55162   jresult = (void *)result;
55163   return jresult;
55164 }
55165
55166
55167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
55168   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55169
55170   arg1 = (Dali::Timer *)jarg1;
55171   {
55172     try {
55173       delete arg1;
55174     } catch (std::out_of_range& e) {
55175       {
55176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55177       };
55178     } catch (std::exception& e) {
55179       {
55180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55181       };
55182     } catch (Dali::DaliException e) {
55183       {
55184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55185       };
55186     } catch (...) {
55187       {
55188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55189       };
55190     }
55191   }
55192
55193 }
55194
55195
55196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
55197   void * jresult ;
55198   Dali::BaseHandle arg1 ;
55199   Dali::BaseHandle *argp1 ;
55200   Dali::Timer result;
55201
55202   argp1 = (Dali::BaseHandle *)jarg1;
55203   if (!argp1) {
55204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
55205     return 0;
55206   }
55207   arg1 = *argp1;
55208   {
55209     try {
55210       result = Dali::Timer::DownCast(arg1);
55211     } catch (std::out_of_range& e) {
55212       {
55213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55214       };
55215     } catch (std::exception& e) {
55216       {
55217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55218       };
55219     } catch (Dali::DaliException e) {
55220       {
55221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55222       };
55223     } catch (...) {
55224       {
55225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55226       };
55227     }
55228   }
55229
55230   jresult = new Dali::Timer((const Dali::Timer &)result);
55231   return jresult;
55232 }
55233
55234
55235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
55236   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55237
55238   arg1 = (Dali::Timer *)jarg1;
55239   {
55240     try {
55241       (arg1)->Start();
55242     } catch (std::out_of_range& e) {
55243       {
55244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55245       };
55246     } catch (std::exception& e) {
55247       {
55248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55249       };
55250     } catch (Dali::DaliException e) {
55251       {
55252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55253       };
55254     } catch (...) {
55255       {
55256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55257       };
55258     }
55259   }
55260
55261 }
55262
55263
55264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
55265   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55266
55267   arg1 = (Dali::Timer *)jarg1;
55268   {
55269     try {
55270       (arg1)->Stop();
55271     } catch (std::out_of_range& e) {
55272       {
55273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55274       };
55275     } catch (std::exception& e) {
55276       {
55277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55278       };
55279     } catch (Dali::DaliException e) {
55280       {
55281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55282       };
55283     } catch (...) {
55284       {
55285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55286       };
55287     }
55288   }
55289
55290 }
55291
55292
55293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
55294   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55295   unsigned int arg2 ;
55296
55297   arg1 = (Dali::Timer *)jarg1;
55298   arg2 = (unsigned int)jarg2;
55299   {
55300     try {
55301       (arg1)->SetInterval(arg2);
55302     } catch (std::out_of_range& e) {
55303       {
55304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55305       };
55306     } catch (std::exception& e) {
55307       {
55308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55309       };
55310     } catch (Dali::DaliException e) {
55311       {
55312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55313       };
55314     } catch (...) {
55315       {
55316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55317       };
55318     }
55319   }
55320
55321 }
55322
55323
55324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
55325   unsigned int jresult ;
55326   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55327   unsigned int result;
55328
55329   arg1 = (Dali::Timer *)jarg1;
55330   {
55331     try {
55332       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
55333     } catch (std::out_of_range& e) {
55334       {
55335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55336       };
55337     } catch (std::exception& e) {
55338       {
55339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55340       };
55341     } catch (Dali::DaliException e) {
55342       {
55343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55344       };
55345     } catch (...) {
55346       {
55347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55348       };
55349     }
55350   }
55351
55352   jresult = result;
55353   return jresult;
55354 }
55355
55356
55357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
55358   unsigned int jresult ;
55359   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55360   bool result;
55361
55362   arg1 = (Dali::Timer *)jarg1;
55363   {
55364     try {
55365       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
55366     } catch (std::out_of_range& e) {
55367       {
55368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55369       };
55370     } catch (std::exception& e) {
55371       {
55372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55373       };
55374     } catch (Dali::DaliException e) {
55375       {
55376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55377       };
55378     } catch (...) {
55379       {
55380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55381       };
55382     }
55383   }
55384
55385   jresult = result;
55386   return jresult;
55387 }
55388
55389
55390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
55391   void * jresult ;
55392   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55393   Dali::Timer::TimerSignalType *result = 0 ;
55394
55395   arg1 = (Dali::Timer *)jarg1;
55396   {
55397     try {
55398       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
55399     } catch (std::out_of_range& e) {
55400       {
55401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55402       };
55403     } catch (std::exception& e) {
55404       {
55405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55406       };
55407     } catch (Dali::DaliException e) {
55408       {
55409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55410       };
55411     } catch (...) {
55412       {
55413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55414       };
55415     }
55416   }
55417
55418   jresult = (void *)result;
55419   return jresult;
55420 }
55421
55422
55423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55424   unsigned int jresult ;
55425   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55426   bool result;
55427
55428   arg1 = (Dali::Signal< bool () > *)jarg1;
55429   {
55430     try {
55431       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55432     } catch (std::out_of_range& e) {
55433       {
55434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55435       };
55436     } catch (std::exception& e) {
55437       {
55438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55439       };
55440     } catch (Dali::DaliException e) {
55441       {
55442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55443       };
55444     } catch (...) {
55445       {
55446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55447       };
55448     }
55449   }
55450
55451   jresult = result;
55452   return jresult;
55453 }
55454
55455
55456 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55457   unsigned long jresult ;
55458   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55459   std::size_t result;
55460
55461   arg1 = (Dali::Signal< bool () > *)jarg1;
55462   {
55463     try {
55464       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
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 = (unsigned long)result;
55485   return jresult;
55486 }
55487
55488
55489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55490   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55491   bool (*arg2)() = (bool (*)()) 0 ;
55492
55493   arg1 = (Dali::Signal< bool () > *)jarg1;
55494   arg2 = (bool (*)())jarg2;
55495   {
55496     try {
55497       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55498     } catch (std::out_of_range& e) {
55499       {
55500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55501       };
55502     } catch (std::exception& e) {
55503       {
55504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55505       };
55506     } catch (Dali::DaliException e) {
55507       {
55508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55509       };
55510     } catch (...) {
55511       {
55512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55513       };
55514     }
55515   }
55516
55517 }
55518
55519
55520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55521   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55522   bool (*arg2)() = (bool (*)()) 0 ;
55523
55524   arg1 = (Dali::Signal< bool () > *)jarg1;
55525   arg2 = (bool (*)())jarg2;
55526   {
55527     try {
55528       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55529     } catch (std::out_of_range& e) {
55530       {
55531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55532       };
55533     } catch (std::exception& e) {
55534       {
55535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55536       };
55537     } catch (Dali::DaliException e) {
55538       {
55539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55540       };
55541     } catch (...) {
55542       {
55543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55544       };
55545     }
55546   }
55547
55548 }
55549
55550
55551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55552   unsigned int jresult ;
55553   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55554   bool result;
55555
55556   arg1 = (Dali::Signal< bool () > *)jarg1;
55557   {
55558     try {
55559       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55560     } catch (std::out_of_range& e) {
55561       {
55562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55563       };
55564     } catch (std::exception& e) {
55565       {
55566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55567       };
55568     } catch (Dali::DaliException e) {
55569       {
55570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55571       };
55572     } catch (...) {
55573       {
55574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55575       };
55576     }
55577   }
55578
55579   jresult = result;
55580   return jresult;
55581 }
55582
55583
55584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55585   void * jresult ;
55586   Dali::Signal< bool () > *result = 0 ;
55587
55588   {
55589     try {
55590       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55591     } catch (std::out_of_range& e) {
55592       {
55593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55594       };
55595     } catch (std::exception& e) {
55596       {
55597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55598       };
55599     } catch (Dali::DaliException e) {
55600       {
55601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55602       };
55603     } catch (...) {
55604       {
55605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55606       };
55607     }
55608   }
55609
55610   jresult = (void *)result;
55611   return jresult;
55612 }
55613
55614
55615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55616   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55617
55618   arg1 = (Dali::Signal< bool () > *)jarg1;
55619   {
55620     try {
55621       delete arg1;
55622     } catch (std::out_of_range& e) {
55623       {
55624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55625       };
55626     } catch (std::exception& e) {
55627       {
55628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55629       };
55630     } catch (Dali::DaliException e) {
55631       {
55632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55633       };
55634     } catch (...) {
55635       {
55636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55637       };
55638     }
55639   }
55640
55641 }
55642
55643
55644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55645   int jresult ;
55646   int result;
55647
55648   {
55649     try {
55650       result = (int)Dali::Toolkit::Visual::Property::TYPE;
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_VISUAL_PROPERTY_SHADER_get() {
55676   int jresult ;
55677   int result;
55678
55679   {
55680     try {
55681       result = (int)Dali::Toolkit::Visual::Property::SHADER;
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_VISUAL_SHADER_VERTEX_get() {
55707   int jresult ;
55708   int result;
55709
55710   {
55711     try {
55712       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
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_VISUAL_SHADER_FRAGMENT_get() {
55738   int jresult ;
55739   int result;
55740
55741   {
55742     try {
55743       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
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_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55769   int jresult ;
55770   int result;
55771
55772   {
55773     try {
55774       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
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_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55800   int jresult ;
55801   int result;
55802
55803   {
55804     try {
55805       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
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_VISUAL_SHADER_HINTS_get() {
55831   int jresult ;
55832   int result;
55833
55834   {
55835     try {
55836       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
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_BORDER_VISUAL_COLOR_get() {
55862   int jresult ;
55863   int result;
55864
55865   {
55866     try {
55867       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
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_BORDER_VISUAL_SIZE_get() {
55893   int jresult ;
55894   int result;
55895
55896   {
55897     try {
55898       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
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_BORDER_VISUAL_ANTI_ALIASING_get() {
55924   int jresult ;
55925   int result;
55926
55927   {
55928     try {
55929       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
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_COLOR_VISUAL_MIX_COLOR_get() {
55955   int jresult ;
55956   int result;
55957
55958   {
55959     try {
55960       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
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_GRADIENT_VISUAL_START_POSITION_get() {
55986   int jresult ;
55987   int result;
55988
55989   {
55990     try {
55991       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
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
56016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
56017   int jresult ;
56018   int result;
56019
56020   {
56021     try {
56022       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
56023     } catch (std::out_of_range& e) {
56024       {
56025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56026       };
56027     } catch (std::exception& e) {
56028       {
56029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56030       };
56031     } catch (Dali::DaliException e) {
56032       {
56033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56034       };
56035     } catch (...) {
56036       {
56037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56038       };
56039     }
56040   }
56041
56042   jresult = (int)result;
56043   return jresult;
56044 }
56045
56046
56047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
56048   int jresult ;
56049   int result;
56050
56051   {
56052     try {
56053       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
56054     } catch (std::out_of_range& e) {
56055       {
56056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56057       };
56058     } catch (std::exception& e) {
56059       {
56060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56061       };
56062     } catch (Dali::DaliException e) {
56063       {
56064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56065       };
56066     } catch (...) {
56067       {
56068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56069       };
56070     }
56071   }
56072
56073   jresult = (int)result;
56074   return jresult;
56075 }
56076
56077
56078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56079   int jresult ;
56080   int result;
56081
56082   {
56083     try {
56084       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56085     } catch (std::out_of_range& e) {
56086       {
56087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56088       };
56089     } catch (std::exception& e) {
56090       {
56091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56092       };
56093     } catch (Dali::DaliException e) {
56094       {
56095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56096       };
56097     } catch (...) {
56098       {
56099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56100       };
56101     }
56102   }
56103
56104   jresult = (int)result;
56105   return jresult;
56106 }
56107
56108
56109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56110   int jresult ;
56111   int result;
56112
56113   {
56114     try {
56115       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56116     } catch (std::out_of_range& e) {
56117       {
56118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56119       };
56120     } catch (std::exception& e) {
56121       {
56122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56123       };
56124     } catch (Dali::DaliException e) {
56125       {
56126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56127       };
56128     } catch (...) {
56129       {
56130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56131       };
56132     }
56133   }
56134
56135   jresult = (int)result;
56136   return jresult;
56137 }
56138
56139
56140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56141   int jresult ;
56142   int result;
56143
56144   {
56145     try {
56146       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
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
56171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56172   int jresult ;
56173   int result;
56174
56175   {
56176     try {
56177       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56178     } catch (std::out_of_range& e) {
56179       {
56180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56181       };
56182     } catch (std::exception& e) {
56183       {
56184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56185       };
56186     } catch (Dali::DaliException e) {
56187       {
56188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56189       };
56190     } catch (...) {
56191       {
56192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56193       };
56194     }
56195   }
56196
56197   jresult = (int)result;
56198   return jresult;
56199 }
56200
56201
56202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56203   int jresult ;
56204   int result;
56205
56206   {
56207     try {
56208       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56209     } catch (std::out_of_range& e) {
56210       {
56211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56212       };
56213     } catch (std::exception& e) {
56214       {
56215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56216       };
56217     } catch (Dali::DaliException e) {
56218       {
56219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56220       };
56221     } catch (...) {
56222       {
56223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56224       };
56225     }
56226   }
56227
56228   jresult = (int)result;
56229   return jresult;
56230 }
56231
56232
56233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56234   int jresult ;
56235   int result;
56236
56237   {
56238     try {
56239       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56240     } catch (std::out_of_range& e) {
56241       {
56242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56243       };
56244     } catch (std::exception& e) {
56245       {
56246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56247       };
56248     } catch (Dali::DaliException e) {
56249       {
56250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56251       };
56252     } catch (...) {
56253       {
56254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56255       };
56256     }
56257   }
56258
56259   jresult = (int)result;
56260   return jresult;
56261 }
56262
56263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
56264   int jresult ;
56265   int result;
56266
56267   {
56268     try {
56269       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
56270     } catch (std::out_of_range& e) {
56271       {
56272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56273       };
56274     } catch (std::exception& e) {
56275       {
56276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56277       };
56278     } catch (Dali::DaliException e) {
56279       {
56280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56281       };
56282     } catch (...) {
56283       {
56284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56285       };
56286     }
56287   }
56288
56289   jresult = (int)result;
56290   return jresult;
56291 }
56292
56293
56294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
56295   int jresult ;
56296   int result;
56297   {
56298     try
56299     {
56300       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
56301     } catch (std::out_of_range& e) {
56302       {
56303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56304       };
56305     } catch (std::exception& e) {
56306       {
56307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56308       };
56309     } catch (Dali::DaliException e) {
56310       {
56311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56312       };
56313     } catch (...) {
56314       {
56315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56316       };
56317     }
56318   }
56319
56320   jresult = (int)result;
56321   return jresult;
56322 }
56323
56324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
56325   int jresult ;
56326   int result;
56327   {
56328     try
56329     {
56330       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
56331     } catch (std::out_of_range& e) {
56332       {
56333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56334       };
56335     } catch (std::exception& e) {
56336       {
56337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56338       };
56339     } catch (Dali::DaliException e) {
56340       {
56341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56342       };
56343     } catch (...) {
56344       {
56345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56346       };
56347     }
56348   }
56349
56350   jresult = (int)result;
56351   return jresult;
56352 }
56353
56354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
56355   int jresult ;
56356   int result;
56357   {
56358     try
56359     {
56360       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
56361     } catch (std::out_of_range& e) {
56362       {
56363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56364       };
56365     } catch (std::exception& e) {
56366       {
56367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56368       };
56369     } catch (Dali::DaliException e) {
56370       {
56371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56372       };
56373     } catch (...) {
56374       {
56375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56376       };
56377     }
56378   }
56379
56380   jresult = (int)result;
56381   return jresult;
56382 }
56383
56384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
56385   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
56386 }
56387
56388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
56389   int jresult ;
56390   int result;
56391   {
56392     try
56393     {
56394       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
56395     } catch (std::out_of_range& e) {
56396       {
56397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56398       };
56399     } catch (std::exception& e) {
56400       {
56401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56402       };
56403     } catch (Dali::DaliException e) {
56404       {
56405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56406       };
56407     } catch (...) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56410       };
56411     }
56412   }
56413
56414   jresult = (int)result;
56415   return jresult;
56416 }
56417
56418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
56419   int jresult ;
56420   int result;
56421   {
56422     try
56423     {
56424       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
56425     } catch (std::out_of_range& e) {
56426       {
56427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56428       };
56429     } catch (std::exception& e) {
56430       {
56431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56432       };
56433     } catch (Dali::DaliException e) {
56434       {
56435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56436       };
56437     } catch (...) {
56438       {
56439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56440       };
56441     }
56442   }
56443
56444   jresult = (int)result;
56445   return jresult;
56446 }
56447
56448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56449   int jresult ;
56450   int result;
56451
56452   {
56453     try {
56454       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56455     } catch (std::out_of_range& e) {
56456       {
56457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56458       };
56459     } catch (std::exception& e) {
56460       {
56461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56462       };
56463     } catch (Dali::DaliException e) {
56464       {
56465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56466       };
56467     } catch (...) {
56468       {
56469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56470       };
56471     }
56472   }
56473
56474   jresult = (int)result;
56475   return jresult;
56476 }
56477
56478
56479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56480   int jresult ;
56481   int result;
56482
56483   {
56484     try {
56485       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56486     } catch (std::out_of_range& e) {
56487       {
56488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56489       };
56490     } catch (std::exception& e) {
56491       {
56492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56493       };
56494     } catch (Dali::DaliException e) {
56495       {
56496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56497       };
56498     } catch (...) {
56499       {
56500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56501       };
56502     }
56503   }
56504
56505   jresult = (int)result;
56506   return jresult;
56507 }
56508
56509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
56510   int jresult ;
56511   int result;
56512   {
56513     try
56514     {
56515       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
56516     } catch (std::out_of_range& e) {
56517       {
56518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56519       };
56520     } catch (std::exception& e) {
56521       {
56522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56523       };
56524     } catch (...) {
56525       {
56526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56527       };
56528     }
56529   }
56530   jresult = (int)result;
56531   return jresult;
56532 }
56533
56534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56535   int jresult ;
56536   int result;
56537   {
56538     try
56539     {
56540       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56541     } catch (std::out_of_range& e) {
56542       {
56543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56544       };
56545     } catch (std::exception& e) {
56546       {
56547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56548       };
56549     } catch (...) {
56550       {
56551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56552       };
56553     }
56554   }
56555   jresult = (int)result;
56556   return jresult;
56557 }
56558
56559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56560   int jresult ;
56561   int result;
56562   {
56563     try
56564     {
56565       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56566     } catch (std::out_of_range& e) {
56567       {
56568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56569       };
56570     } catch (std::exception& e) {
56571       {
56572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56573       };
56574     } catch (...) {
56575       {
56576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56577       };
56578     }
56579   }
56580   jresult = (int)result;
56581   return jresult;
56582 }
56583
56584
56585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56586   int jresult ;
56587   int result;
56588   {
56589     try
56590     {
56591       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56592     } catch (std::out_of_range& e) {
56593       {
56594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56595       };
56596     } catch (std::exception& e) {
56597       {
56598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56599       };
56600     } catch (...) {
56601       {
56602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56603       };
56604     }
56605   }
56606   jresult = (int)result;
56607   return jresult;
56608 }
56609
56610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56611   int jresult ;
56612   int result;
56613   {
56614     try
56615     {
56616       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56617     } catch (std::out_of_range& e) {
56618       {
56619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56620       };
56621     } catch (std::exception& e) {
56622       {
56623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56624       };
56625     } catch (...) {
56626       {
56627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56628       };
56629     }
56630   }
56631   jresult = (int)result;
56632   return jresult;
56633 }
56634
56635
56636
56637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56638   int jresult ;
56639   int result;
56640
56641   {
56642     try {
56643       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56644     } catch (std::out_of_range& e) {
56645       {
56646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56647       };
56648     } catch (std::exception& e) {
56649       {
56650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56651       };
56652     } catch (Dali::DaliException e) {
56653       {
56654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56655       };
56656     } catch (...) {
56657       {
56658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56659       };
56660     }
56661   }
56662
56663   jresult = (int)result;
56664   return jresult;
56665 }
56666
56667
56668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56669   int jresult ;
56670   int result;
56671
56672   {
56673     try {
56674       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56675     } catch (std::out_of_range& e) {
56676       {
56677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56678       };
56679     } catch (std::exception& e) {
56680       {
56681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56682       };
56683     } catch (Dali::DaliException e) {
56684       {
56685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56686       };
56687     } catch (...) {
56688       {
56689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56690       };
56691     }
56692   }
56693
56694   jresult = (int)result;
56695   return jresult;
56696 }
56697
56698
56699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56700   int jresult ;
56701   int result;
56702
56703   {
56704     try {
56705       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56706     } catch (std::out_of_range& e) {
56707       {
56708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56709       };
56710     } catch (std::exception& e) {
56711       {
56712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56713       };
56714     } catch (Dali::DaliException e) {
56715       {
56716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56717       };
56718     } catch (...) {
56719       {
56720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56721       };
56722     }
56723   }
56724
56725   jresult = (int)result;
56726   return jresult;
56727 }
56728
56729
56730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56731   int jresult ;
56732   int result;
56733
56734   {
56735     try {
56736       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56737     } catch (std::out_of_range& e) {
56738       {
56739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56740       };
56741     } catch (std::exception& e) {
56742       {
56743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56744       };
56745     } catch (Dali::DaliException e) {
56746       {
56747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56748       };
56749     } catch (...) {
56750       {
56751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56752       };
56753     }
56754   }
56755
56756   jresult = (int)result;
56757   return jresult;
56758 }
56759
56760
56761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56762   int jresult ;
56763   int result;
56764
56765   {
56766     try {
56767       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56768     } catch (std::out_of_range& e) {
56769       {
56770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56771       };
56772     } catch (std::exception& e) {
56773       {
56774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56775       };
56776     } catch (Dali::DaliException e) {
56777       {
56778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56779       };
56780     } catch (...) {
56781       {
56782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56783       };
56784     }
56785   }
56786
56787   jresult = (int)result;
56788   return jresult;
56789 }
56790
56791
56792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56793   int jresult ;
56794   int result;
56795
56796   {
56797     try {
56798       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56799     } catch (std::out_of_range& e) {
56800       {
56801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56802       };
56803     } catch (std::exception& e) {
56804       {
56805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56806       };
56807     } catch (Dali::DaliException e) {
56808       {
56809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56810       };
56811     } catch (...) {
56812       {
56813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56814       };
56815     }
56816   }
56817
56818   jresult = (int)result;
56819   return jresult;
56820 }
56821
56822
56823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56824   int jresult ;
56825   int result;
56826
56827   {
56828     try {
56829       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56830     } catch (std::out_of_range& e) {
56831       {
56832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56833       };
56834     } catch (std::exception& e) {
56835       {
56836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56837       };
56838     } catch (Dali::DaliException e) {
56839       {
56840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56841       };
56842     } catch (...) {
56843       {
56844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56845       };
56846     }
56847   }
56848
56849   jresult = (int)result;
56850   return jresult;
56851 }
56852
56853 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56854   int jresult ;
56855   int result;
56856
56857   {
56858     try {
56859       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56860     } catch (std::out_of_range& e) {
56861       {
56862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56863       };
56864     } catch (std::exception& e) {
56865       {
56866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56867       };
56868     } catch (...) {
56869       {
56870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56871       };
56872     }
56873   }
56874   jresult = (int)result;
56875   return jresult;
56876 }
56877
56878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56879   int jresult ;
56880   int result;
56881
56882   {
56883     try {
56884       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
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_MESH_VISUAL_MATERIAL_URL_get() {
56910   int jresult ;
56911   int result;
56912
56913   {
56914     try {
56915       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
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_MESH_VISUAL_TEXTURES_PATH_get() {
56941   int jresult ;
56942   int result;
56943
56944   {
56945     try {
56946       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
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_MESH_VISUAL_SHADING_MODE_get() {
56972   int jresult ;
56973   int result;
56974
56975   {
56976     try {
56977       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
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_MESH_VISUAL_USE_MIPMAPPING_get() {
57003   int jresult ;
57004   int result;
57005
57006   {
57007     try {
57008       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
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_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57034   int jresult ;
57035   int result;
57036
57037   {
57038     try {
57039       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
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_MESH_VISUAL_LIGHT_POSITION_get() {
57065   int jresult ;
57066   int result;
57067
57068   {
57069     try {
57070       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
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_SHAPE_get() {
57096   int jresult ;
57097   int result;
57098
57099   {
57100     try {
57101       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
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_MIX_COLOR_get() {
57127   int jresult ;
57128   int result;
57129
57130   {
57131     try {
57132       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
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_SLICES_get() {
57158   int jresult ;
57159   int result;
57160
57161   {
57162     try {
57163       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
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_STACKS_get() {
57189   int jresult ;
57190   int result;
57191
57192   {
57193     try {
57194       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
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_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57220   int jresult ;
57221   int result;
57222
57223   {
57224     try {
57225       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
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_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57251   int jresult ;
57252   int result;
57253
57254   {
57255     try {
57256       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
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_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57282   int jresult ;
57283   int result;
57284
57285   {
57286     try {
57287       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
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_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57313   int jresult ;
57314   int result;
57315
57316   {
57317     try {
57318       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
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_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57344   int jresult ;
57345   int result;
57346
57347   {
57348     try {
57349       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
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_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57375   int jresult ;
57376   int result;
57377
57378   {
57379     try {
57380       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
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_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57406   int jresult ;
57407   int result;
57408
57409   {
57410     try {
57411       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
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_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57437   int jresult ;
57438   int result;
57439
57440   {
57441     try {
57442       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
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_TEXT_get() {
57468   int jresult ;
57469   int result;
57470
57471   {
57472     try {
57473       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
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 int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57499   int jresult ;
57500   int result;
57501
57502   {
57503     try {
57504       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
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 = (int)result;
57525   return jresult;
57526 }
57527
57528
57529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57530   int jresult ;
57531   int result;
57532
57533   {
57534     try {
57535       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
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 = (int)result;
57556   return jresult;
57557 }
57558
57559
57560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57561   int jresult ;
57562   int result;
57563
57564   {
57565     try {
57566       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57567     } catch (std::out_of_range& e) {
57568       {
57569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57570       };
57571     } catch (std::exception& e) {
57572       {
57573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57574       };
57575     } catch (Dali::DaliException e) {
57576       {
57577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57578       };
57579     } catch (...) {
57580       {
57581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57582       };
57583     }
57584   }
57585
57586   jresult = (int)result;
57587   return jresult;
57588 }
57589
57590
57591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57592   int jresult ;
57593   int result;
57594
57595   {
57596     try {
57597       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57598     } catch (std::out_of_range& e) {
57599       {
57600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57601       };
57602     } catch (std::exception& e) {
57603       {
57604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57605       };
57606     } catch (Dali::DaliException e) {
57607       {
57608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57609       };
57610     } catch (...) {
57611       {
57612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57613       };
57614     }
57615   }
57616
57617   jresult = (int)result;
57618   return jresult;
57619 }
57620
57621
57622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57623   int jresult ;
57624   int result;
57625
57626   {
57627     try {
57628       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57629     } catch (std::out_of_range& e) {
57630       {
57631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57632       };
57633     } catch (std::exception& e) {
57634       {
57635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57636       };
57637     } catch (Dali::DaliException e) {
57638       {
57639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57640       };
57641     } catch (...) {
57642       {
57643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57644       };
57645     }
57646   }
57647
57648   jresult = (int)result;
57649   return jresult;
57650 }
57651
57652
57653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57654   int jresult ;
57655   int result;
57656
57657   {
57658     try {
57659       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57660     } catch (std::out_of_range& e) {
57661       {
57662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57663       };
57664     } catch (std::exception& e) {
57665       {
57666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57667       };
57668     } catch (Dali::DaliException e) {
57669       {
57670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57671       };
57672     } catch (...) {
57673       {
57674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57675       };
57676     }
57677   }
57678
57679   jresult = (int)result;
57680   return jresult;
57681 }
57682
57683
57684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57685   int jresult ;
57686   int result;
57687
57688   {
57689     try {
57690       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57691     } catch (std::out_of_range& e) {
57692       {
57693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57694       };
57695     } catch (std::exception& e) {
57696       {
57697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57698       };
57699     } catch (Dali::DaliException e) {
57700       {
57701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57702       };
57703     } catch (...) {
57704       {
57705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57706       };
57707     }
57708   }
57709
57710   jresult = (int)result;
57711   return jresult;
57712 }
57713
57714
57715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57716   int jresult ;
57717   int result;
57718
57719   {
57720     try {
57721       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57722     } catch (std::out_of_range& e) {
57723       {
57724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57725       };
57726     } catch (std::exception& e) {
57727       {
57728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57729       };
57730     } catch (Dali::DaliException e) {
57731       {
57732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57733       };
57734     } catch (...) {
57735       {
57736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57737       };
57738     }
57739   }
57740
57741   jresult = (int)result;
57742   return jresult;
57743 }
57744
57745
57746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57747   void * jresult ;
57748   Dali::Toolkit::Builder *result = 0 ;
57749
57750   {
57751     try {
57752       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57753     } catch (std::out_of_range& e) {
57754       {
57755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57756       };
57757     } catch (std::exception& e) {
57758       {
57759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57760       };
57761     } catch (Dali::DaliException e) {
57762       {
57763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57764       };
57765     } catch (...) {
57766       {
57767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57768       };
57769     }
57770   }
57771
57772   jresult = (void *)result;
57773   return jresult;
57774 }
57775
57776
57777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57778   void * jresult ;
57779   Dali::Toolkit::Builder result;
57780
57781   {
57782     try {
57783       result = Dali::Toolkit::Builder::New();
57784     } catch (std::out_of_range& e) {
57785       {
57786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57787       };
57788     } catch (std::exception& e) {
57789       {
57790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57791       };
57792     } catch (Dali::DaliException e) {
57793       {
57794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57795       };
57796     } catch (...) {
57797       {
57798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57799       };
57800     }
57801   }
57802
57803   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57804   return jresult;
57805 }
57806
57807
57808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57809   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57810
57811   arg1 = (Dali::Toolkit::Builder *)jarg1;
57812   {
57813     try {
57814       delete arg1;
57815     } catch (std::out_of_range& e) {
57816       {
57817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57818       };
57819     } catch (std::exception& e) {
57820       {
57821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57822       };
57823     } catch (Dali::DaliException e) {
57824       {
57825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57826       };
57827     } catch (...) {
57828       {
57829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57830       };
57831     }
57832   }
57833
57834 }
57835
57836
57837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57838   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57839   std::string *arg2 = 0 ;
57840   Dali::Toolkit::Builder::UIFormat arg3 ;
57841
57842   arg1 = (Dali::Toolkit::Builder *)jarg1;
57843   if (!jarg2) {
57844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57845     return ;
57846   }
57847   std::string arg2_str(jarg2);
57848   arg2 = &arg2_str;
57849   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57850   {
57851     try {
57852       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57853     } catch (std::out_of_range& e) {
57854       {
57855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57856       };
57857     } catch (std::exception& e) {
57858       {
57859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57860       };
57861     } catch (Dali::DaliException e) {
57862       {
57863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57864       };
57865     } catch (...) {
57866       {
57867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57868       };
57869     }
57870   }
57871
57872
57873   //argout typemap for const std::string&
57874
57875 }
57876
57877
57878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57879   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57880   std::string *arg2 = 0 ;
57881
57882   arg1 = (Dali::Toolkit::Builder *)jarg1;
57883   if (!jarg2) {
57884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57885     return ;
57886   }
57887   std::string arg2_str(jarg2);
57888   arg2 = &arg2_str;
57889   {
57890     try {
57891       (arg1)->LoadFromString((std::string const &)*arg2);
57892     } catch (std::out_of_range& e) {
57893       {
57894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57895       };
57896     } catch (std::exception& e) {
57897       {
57898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57899       };
57900     } catch (Dali::DaliException e) {
57901       {
57902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57903       };
57904     } catch (...) {
57905       {
57906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57907       };
57908     }
57909   }
57910
57911
57912   //argout typemap for const std::string&
57913
57914 }
57915
57916
57917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57918   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57919   Dali::Property::Map *arg2 = 0 ;
57920
57921   arg1 = (Dali::Toolkit::Builder *)jarg1;
57922   arg2 = (Dali::Property::Map *)jarg2;
57923   if (!arg2) {
57924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57925     return ;
57926   }
57927   {
57928     try {
57929       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57930     } catch (std::out_of_range& e) {
57931       {
57932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57933       };
57934     } catch (std::exception& e) {
57935       {
57936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57937       };
57938     } catch (Dali::DaliException e) {
57939       {
57940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57941       };
57942     } catch (...) {
57943       {
57944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57945       };
57946     }
57947   }
57948
57949 }
57950
57951
57952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57953   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57954   std::string *arg2 = 0 ;
57955   Dali::Property::Value *arg3 = 0 ;
57956
57957   arg1 = (Dali::Toolkit::Builder *)jarg1;
57958   if (!jarg2) {
57959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57960     return ;
57961   }
57962   std::string arg2_str(jarg2);
57963   arg2 = &arg2_str;
57964   arg3 = (Dali::Property::Value *)jarg3;
57965   if (!arg3) {
57966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57967     return ;
57968   }
57969   {
57970     try {
57971       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57972     } catch (std::out_of_range& e) {
57973       {
57974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57975       };
57976     } catch (std::exception& e) {
57977       {
57978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57979       };
57980     } catch (Dali::DaliException e) {
57981       {
57982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57983       };
57984     } catch (...) {
57985       {
57986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57987       };
57988     }
57989   }
57990
57991
57992   //argout typemap for const std::string&
57993
57994 }
57995
57996
57997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57998   void * jresult ;
57999   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58000   Dali::Property::Map *result = 0 ;
58001
58002   arg1 = (Dali::Toolkit::Builder *)jarg1;
58003   {
58004     try {
58005       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58006     } catch (std::out_of_range& e) {
58007       {
58008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58009       };
58010     } catch (std::exception& e) {
58011       {
58012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58013       };
58014     } catch (Dali::DaliException e) {
58015       {
58016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58017       };
58018     } catch (...) {
58019       {
58020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58021       };
58022     }
58023   }
58024
58025   jresult = (void *)result;
58026   return jresult;
58027 }
58028
58029
58030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
58031   void * jresult ;
58032   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58033   std::string *arg2 = 0 ;
58034   Dali::Property::Value *result = 0 ;
58035
58036   arg1 = (Dali::Toolkit::Builder *)jarg1;
58037   if (!jarg2) {
58038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58039     return 0;
58040   }
58041   std::string arg2_str(jarg2);
58042   arg2 = &arg2_str;
58043   {
58044     try {
58045       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58046     } catch (std::out_of_range& e) {
58047       {
58048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58049       };
58050     } catch (std::exception& e) {
58051       {
58052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58053       };
58054     } catch (Dali::DaliException e) {
58055       {
58056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58057       };
58058     } catch (...) {
58059       {
58060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58061       };
58062     }
58063   }
58064
58065   jresult = (void *)result;
58066
58067   //argout typemap for const std::string&
58068
58069   return jresult;
58070 }
58071
58072
58073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58074   void * jresult ;
58075   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58076   std::string *arg2 = 0 ;
58077   Dali::Animation result;
58078
58079   arg1 = (Dali::Toolkit::Builder *)jarg1;
58080   if (!jarg2) {
58081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58082     return 0;
58083   }
58084   std::string arg2_str(jarg2);
58085   arg2 = &arg2_str;
58086   {
58087     try {
58088       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58089     } catch (std::out_of_range& e) {
58090       {
58091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58092       };
58093     } catch (std::exception& e) {
58094       {
58095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58096       };
58097     } catch (Dali::DaliException e) {
58098       {
58099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58100       };
58101     } catch (...) {
58102       {
58103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58104       };
58105     }
58106   }
58107
58108   jresult = new Dali::Animation((const Dali::Animation &)result);
58109
58110   //argout typemap for const std::string&
58111
58112   return jresult;
58113 }
58114
58115
58116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58117   void * jresult ;
58118   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58119   std::string *arg2 = 0 ;
58120   Dali::Property::Map *arg3 = 0 ;
58121   Dali::Animation 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   arg3 = (Dali::Property::Map *)jarg3;
58131   if (!arg3) {
58132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58133     return 0;
58134   }
58135   {
58136     try {
58137       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58138     } catch (std::out_of_range& e) {
58139       {
58140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58141       };
58142     } catch (std::exception& e) {
58143       {
58144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58145       };
58146     } catch (Dali::DaliException e) {
58147       {
58148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58149       };
58150     } catch (...) {
58151       {
58152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58153       };
58154     }
58155   }
58156
58157   jresult = new Dali::Animation((const Dali::Animation &)result);
58158
58159   //argout typemap for const std::string&
58160
58161   return jresult;
58162 }
58163
58164
58165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58166   void * jresult ;
58167   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58168   std::string *arg2 = 0 ;
58169   Dali::Actor arg3 ;
58170   Dali::Actor *argp3 ;
58171   Dali::Animation result;
58172
58173   arg1 = (Dali::Toolkit::Builder *)jarg1;
58174   if (!jarg2) {
58175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58176     return 0;
58177   }
58178   std::string arg2_str(jarg2);
58179   arg2 = &arg2_str;
58180   argp3 = (Dali::Actor *)jarg3;
58181   if (!argp3) {
58182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58183     return 0;
58184   }
58185   arg3 = *argp3;
58186   {
58187     try {
58188       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58189     } catch (std::out_of_range& e) {
58190       {
58191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58192       };
58193     } catch (std::exception& e) {
58194       {
58195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58196       };
58197     } catch (Dali::DaliException e) {
58198       {
58199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58200       };
58201     } catch (...) {
58202       {
58203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58204       };
58205     }
58206   }
58207
58208   jresult = new Dali::Animation((const Dali::Animation &)result);
58209
58210   //argout typemap for const std::string&
58211
58212   return jresult;
58213 }
58214
58215
58216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58217   void * jresult ;
58218   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58219   std::string *arg2 = 0 ;
58220   Dali::Property::Map *arg3 = 0 ;
58221   Dali::Actor arg4 ;
58222   Dali::Actor *argp4 ;
58223   Dali::Animation result;
58224
58225   arg1 = (Dali::Toolkit::Builder *)jarg1;
58226   if (!jarg2) {
58227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58228     return 0;
58229   }
58230   std::string arg2_str(jarg2);
58231   arg2 = &arg2_str;
58232   arg3 = (Dali::Property::Map *)jarg3;
58233   if (!arg3) {
58234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58235     return 0;
58236   }
58237   argp4 = (Dali::Actor *)jarg4;
58238   if (!argp4) {
58239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58240     return 0;
58241   }
58242   arg4 = *argp4;
58243   {
58244     try {
58245       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58246     } catch (std::out_of_range& e) {
58247       {
58248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58249       };
58250     } catch (std::exception& e) {
58251       {
58252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58253       };
58254     } catch (Dali::DaliException e) {
58255       {
58256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58257       };
58258     } catch (...) {
58259       {
58260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58261       };
58262     }
58263   }
58264
58265   jresult = new Dali::Animation((const Dali::Animation &)result);
58266
58267   //argout typemap for const std::string&
58268
58269   return jresult;
58270 }
58271
58272
58273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58274   void * jresult ;
58275   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58276   std::string *arg2 = 0 ;
58277   Dali::BaseHandle result;
58278
58279   arg1 = (Dali::Toolkit::Builder *)jarg1;
58280   if (!jarg2) {
58281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58282     return 0;
58283   }
58284   std::string arg2_str(jarg2);
58285   arg2 = &arg2_str;
58286   {
58287     try {
58288       result = (arg1)->Create((std::string const &)*arg2);
58289     } catch (std::out_of_range& e) {
58290       {
58291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58292       };
58293     } catch (std::exception& e) {
58294       {
58295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58296       };
58297     } catch (Dali::DaliException e) {
58298       {
58299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58300       };
58301     } catch (...) {
58302       {
58303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58304       };
58305     }
58306   }
58307
58308   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58309
58310   //argout typemap for const std::string&
58311
58312   return jresult;
58313 }
58314
58315
58316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58317   void * jresult ;
58318   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58319   std::string *arg2 = 0 ;
58320   Dali::Property::Map *arg3 = 0 ;
58321   Dali::BaseHandle result;
58322
58323   arg1 = (Dali::Toolkit::Builder *)jarg1;
58324   if (!jarg2) {
58325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58326     return 0;
58327   }
58328   std::string arg2_str(jarg2);
58329   arg2 = &arg2_str;
58330   arg3 = (Dali::Property::Map *)jarg3;
58331   if (!arg3) {
58332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58333     return 0;
58334   }
58335   {
58336     try {
58337       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58338     } catch (std::out_of_range& e) {
58339       {
58340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58341       };
58342     } catch (std::exception& e) {
58343       {
58344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58345       };
58346     } catch (Dali::DaliException e) {
58347       {
58348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58349       };
58350     } catch (...) {
58351       {
58352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58353       };
58354     }
58355   }
58356
58357   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58358
58359   //argout typemap for const std::string&
58360
58361   return jresult;
58362 }
58363
58364
58365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58366   void * jresult ;
58367   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58368   std::string *arg2 = 0 ;
58369   Dali::BaseHandle result;
58370
58371   arg1 = (Dali::Toolkit::Builder *)jarg1;
58372   if (!jarg2) {
58373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58374     return 0;
58375   }
58376   std::string arg2_str(jarg2);
58377   arg2 = &arg2_str;
58378   {
58379     try {
58380       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58381     } catch (std::out_of_range& e) {
58382       {
58383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58384       };
58385     } catch (std::exception& e) {
58386       {
58387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58388       };
58389     } catch (Dali::DaliException e) {
58390       {
58391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58392       };
58393     } catch (...) {
58394       {
58395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58396       };
58397     }
58398   }
58399
58400   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58401
58402   //argout typemap for const std::string&
58403
58404   return jresult;
58405 }
58406
58407
58408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58409   unsigned int jresult ;
58410   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58411   std::string *arg2 = 0 ;
58412   Dali::Handle *arg3 = 0 ;
58413   bool result;
58414
58415   arg1 = (Dali::Toolkit::Builder *)jarg1;
58416   if (!jarg2) {
58417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58418     return 0;
58419   }
58420   std::string arg2_str(jarg2);
58421   arg2 = &arg2_str;
58422   arg3 = (Dali::Handle *)jarg3;
58423   if (!arg3) {
58424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58425     return 0;
58426   }
58427   {
58428     try {
58429       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58430     } catch (std::out_of_range& e) {
58431       {
58432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58433       };
58434     } catch (std::exception& e) {
58435       {
58436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58437       };
58438     } catch (Dali::DaliException e) {
58439       {
58440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58441       };
58442     } catch (...) {
58443       {
58444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58445       };
58446     }
58447   }
58448
58449   jresult = result;
58450
58451   //argout typemap for const std::string&
58452
58453   return jresult;
58454 }
58455
58456
58457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58458   unsigned int jresult ;
58459   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58460   Dali::Handle *arg2 = 0 ;
58461   std::string *arg3 = 0 ;
58462   bool result;
58463
58464   arg1 = (Dali::Toolkit::Builder *)jarg1;
58465   arg2 = (Dali::Handle *)jarg2;
58466   if (!arg2) {
58467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58468     return 0;
58469   }
58470   if (!jarg3) {
58471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58472     return 0;
58473   }
58474   std::string arg3_str(jarg3);
58475   arg3 = &arg3_str;
58476   {
58477     try {
58478       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58479     } catch (std::out_of_range& e) {
58480       {
58481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58482       };
58483     } catch (std::exception& e) {
58484       {
58485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58486       };
58487     } catch (Dali::DaliException e) {
58488       {
58489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58490       };
58491     } catch (...) {
58492       {
58493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58494       };
58495     }
58496   }
58497
58498   jresult = result;
58499
58500   //argout typemap for const std::string&
58501
58502   return jresult;
58503 }
58504
58505
58506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58507   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58508   Dali::Actor arg2 ;
58509   Dali::Actor *argp2 ;
58510
58511   arg1 = (Dali::Toolkit::Builder *)jarg1;
58512   argp2 = (Dali::Actor *)jarg2;
58513   if (!argp2) {
58514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58515     return ;
58516   }
58517   arg2 = *argp2;
58518   {
58519     try {
58520       (arg1)->AddActors(arg2);
58521     } catch (std::out_of_range& e) {
58522       {
58523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58524       };
58525     } catch (std::exception& e) {
58526       {
58527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58528       };
58529     } catch (Dali::DaliException e) {
58530       {
58531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58532       };
58533     } catch (...) {
58534       {
58535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58536       };
58537     }
58538   }
58539
58540 }
58541
58542
58543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58544   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58545   std::string *arg2 = 0 ;
58546   Dali::Actor arg3 ;
58547   Dali::Actor *argp3 ;
58548
58549   arg1 = (Dali::Toolkit::Builder *)jarg1;
58550   if (!jarg2) {
58551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58552     return ;
58553   }
58554   std::string arg2_str(jarg2);
58555   arg2 = &arg2_str;
58556   argp3 = (Dali::Actor *)jarg3;
58557   if (!argp3) {
58558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58559     return ;
58560   }
58561   arg3 = *argp3;
58562   {
58563     try {
58564       (arg1)->AddActors((std::string const &)*arg2,arg3);
58565     } catch (std::out_of_range& e) {
58566       {
58567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58568       };
58569     } catch (std::exception& e) {
58570       {
58571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58572       };
58573     } catch (Dali::DaliException e) {
58574       {
58575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58576       };
58577     } catch (...) {
58578       {
58579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58580       };
58581     }
58582   }
58583
58584
58585   //argout typemap for const std::string&
58586
58587 }
58588
58589
58590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58591   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58592   std::string *arg2 = 0 ;
58593
58594   arg1 = (Dali::Toolkit::Builder *)jarg1;
58595   if (!jarg2) {
58596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58597     return ;
58598   }
58599   std::string arg2_str(jarg2);
58600   arg2 = &arg2_str;
58601   {
58602     try {
58603       (arg1)->CreateRenderTask((std::string const &)*arg2);
58604     } catch (std::out_of_range& e) {
58605       {
58606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58607       };
58608     } catch (std::exception& e) {
58609       {
58610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58611       };
58612     } catch (Dali::DaliException e) {
58613       {
58614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58615       };
58616     } catch (...) {
58617       {
58618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58619       };
58620     }
58621   }
58622
58623
58624   //argout typemap for const std::string&
58625
58626 }
58627
58628
58629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58630   void * jresult ;
58631   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58632   std::string *arg2 = 0 ;
58633   Dali::Path result;
58634
58635   arg1 = (Dali::Toolkit::Builder *)jarg1;
58636   if (!jarg2) {
58637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58638     return 0;
58639   }
58640   std::string arg2_str(jarg2);
58641   arg2 = &arg2_str;
58642   {
58643     try {
58644       result = (arg1)->GetPath((std::string const &)*arg2);
58645     } catch (std::out_of_range& e) {
58646       {
58647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58648       };
58649     } catch (std::exception& e) {
58650       {
58651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58652       };
58653     } catch (Dali::DaliException e) {
58654       {
58655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58656       };
58657     } catch (...) {
58658       {
58659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58660       };
58661     }
58662   }
58663
58664   jresult = new Dali::Path((const Dali::Path &)result);
58665
58666   //argout typemap for const std::string&
58667
58668   return jresult;
58669 }
58670
58671
58672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58673   void * jresult ;
58674   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58675   std::string *arg2 = 0 ;
58676   Dali::PathConstrainer result;
58677
58678   arg1 = (Dali::Toolkit::Builder *)jarg1;
58679   if (!jarg2) {
58680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58681     return 0;
58682   }
58683   std::string arg2_str(jarg2);
58684   arg2 = &arg2_str;
58685   {
58686     try {
58687       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58688     } catch (std::out_of_range& e) {
58689       {
58690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58691       };
58692     } catch (std::exception& e) {
58693       {
58694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58695       };
58696     } catch (Dali::DaliException e) {
58697       {
58698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58699       };
58700     } catch (...) {
58701       {
58702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58703       };
58704     }
58705   }
58706
58707   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58708
58709   //argout typemap for const std::string&
58710
58711   return jresult;
58712 }
58713
58714
58715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58716   void * jresult ;
58717   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58718   std::string *arg2 = 0 ;
58719   Dali::LinearConstrainer result;
58720
58721   arg1 = (Dali::Toolkit::Builder *)jarg1;
58722   if (!jarg2) {
58723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58724     return 0;
58725   }
58726   std::string arg2_str(jarg2);
58727   arg2 = &arg2_str;
58728   {
58729     try {
58730       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58731     } catch (std::out_of_range& e) {
58732       {
58733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58734       };
58735     } catch (std::exception& e) {
58736       {
58737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58738       };
58739     } catch (Dali::DaliException e) {
58740       {
58741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58742       };
58743     } catch (...) {
58744       {
58745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58746       };
58747     }
58748   }
58749
58750   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58751
58752   //argout typemap for const std::string&
58753
58754   return jresult;
58755 }
58756
58757
58758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58759   void * jresult ;
58760   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58761   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58762
58763   arg1 = (Dali::Toolkit::Builder *)jarg1;
58764   {
58765     try {
58766       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
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 void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58792   void * jresult ;
58793   Dali::Toolkit::TransitionData *result = 0 ;
58794
58795   {
58796     try {
58797       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58798     } catch (std::out_of_range& e) {
58799       {
58800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58801       };
58802     } catch (std::exception& e) {
58803       {
58804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58805       };
58806     } catch (Dali::DaliException e) {
58807       {
58808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58809       };
58810     } catch (...) {
58811       {
58812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58813       };
58814     }
58815   }
58816
58817   jresult = (void *)result;
58818   return jresult;
58819 }
58820
58821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58822   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58823
58824   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58825   {
58826     try {
58827       delete arg1;
58828     } catch (std::out_of_range& e) {
58829       {
58830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58831       };
58832     } catch (std::exception& e) {
58833       {
58834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58835       };
58836     } catch (Dali::DaliException e) {
58837       {
58838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58839       };
58840     } catch (...) {
58841       {
58842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58843       };
58844     }
58845   }
58846
58847 }
58848
58849
58850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58851   void * jresult ;
58852   Dali::Property::Map *arg1 = 0 ;
58853   Dali::Toolkit::TransitionData result;
58854
58855   arg1 = (Dali::Property::Map *)jarg1;
58856   if (!arg1) {
58857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58858     return 0;
58859   }
58860   {
58861     try {
58862       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58863     } catch (std::out_of_range& e) {
58864       {
58865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58866       };
58867     } catch (std::exception& e) {
58868       {
58869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58870       };
58871     } catch (Dali::DaliException e) {
58872       {
58873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58874       };
58875     } catch (...) {
58876       {
58877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58878       };
58879     }
58880   }
58881
58882   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58883   return jresult;
58884 }
58885
58886
58887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58888   void * jresult ;
58889   Dali::Property::Array *arg1 = 0 ;
58890   Dali::Toolkit::TransitionData result;
58891
58892   arg1 = (Dali::Property::Array *)jarg1;
58893   if (!arg1) {
58894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58895     return 0;
58896   }
58897   {
58898     try {
58899       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58900     } catch (std::out_of_range& e) {
58901       {
58902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58903       };
58904     } catch (std::exception& e) {
58905       {
58906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58907       };
58908     } catch (Dali::DaliException e) {
58909       {
58910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58911       };
58912     } catch (...) {
58913       {
58914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58915       };
58916     }
58917   }
58918
58919   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58920   return jresult;
58921 }
58922
58923
58924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58925   void * jresult ;
58926   Dali::BaseHandle arg1 ;
58927   Dali::BaseHandle *argp1 ;
58928   Dali::Toolkit::TransitionData result;
58929
58930   argp1 = (Dali::BaseHandle *)jarg1;
58931   if (!argp1) {
58932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58933     return 0;
58934   }
58935   arg1 = *argp1;
58936   {
58937     try {
58938       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58939     } catch (std::out_of_range& e) {
58940       {
58941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58942       };
58943     } catch (std::exception& e) {
58944       {
58945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58946       };
58947     } catch (Dali::DaliException e) {
58948       {
58949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58950       };
58951     } catch (...) {
58952       {
58953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58954       };
58955     }
58956   }
58957
58958   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58959   return jresult;
58960 }
58961
58962
58963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58964   void * jresult ;
58965   Dali::Toolkit::TransitionData *arg1 = 0 ;
58966   Dali::Toolkit::TransitionData *result = 0 ;
58967
58968   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58969   if (!arg1) {
58970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58971     return 0;
58972   }
58973   {
58974     try {
58975       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58976     } catch (std::out_of_range& e) {
58977       {
58978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58979       };
58980     } catch (std::exception& e) {
58981       {
58982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58983       };
58984     } catch (Dali::DaliException e) {
58985       {
58986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58987       };
58988     } catch (...) {
58989       {
58990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58991       };
58992     }
58993   }
58994
58995   jresult = (void *)result;
58996   return jresult;
58997 }
58998
58999
59000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
59001   void * jresult ;
59002   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59003   Dali::Toolkit::TransitionData *arg2 = 0 ;
59004   Dali::Toolkit::TransitionData *result = 0 ;
59005
59006   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59007   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59008   if (!arg2) {
59009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59010     return 0;
59011   }
59012   {
59013     try {
59014       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59015     } catch (std::out_of_range& e) {
59016       {
59017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59018       };
59019     } catch (std::exception& e) {
59020       {
59021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59022       };
59023     } catch (Dali::DaliException e) {
59024       {
59025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59026       };
59027     } catch (...) {
59028       {
59029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59030       };
59031     }
59032   }
59033
59034   jresult = (void *)result;
59035   return jresult;
59036 }
59037
59038
59039 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
59040   unsigned long jresult ;
59041   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59042   size_t result;
59043
59044   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59045   {
59046     try {
59047       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59048     } catch (std::out_of_range& e) {
59049       {
59050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59051       };
59052     } catch (std::exception& e) {
59053       {
59054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59055       };
59056     } catch (Dali::DaliException e) {
59057       {
59058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59059       };
59060     } catch (...) {
59061       {
59062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59063       };
59064     }
59065   }
59066
59067   jresult = (unsigned long)result;
59068   return jresult;
59069 }
59070
59071
59072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59073   void * jresult ;
59074   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59075   size_t arg2 ;
59076   Dali::Property::Map result;
59077
59078   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59079   arg2 = (size_t)jarg2;
59080   {
59081     try {
59082       result = (arg1)->GetAnimatorAt(arg2);
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 = new Dali::Property::Map((const Dali::Property::Map &)result);
59103   return jresult;
59104 }
59105
59106
59107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59108   int jresult ;
59109   int result;
59110
59111   {
59112     try {
59113       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
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_LAYOUT_get() {
59139   int jresult ;
59140   int result;
59141
59142   {
59143     try {
59144       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
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_WAIT_TIME_get() {
59170   int jresult ;
59171   int result;
59172
59173   {
59174     try {
59175       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
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_BACKGROUND_get() {
59201   int jresult ;
59202   int result;
59203
59204   {
59205     try {
59206       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
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_get() {
59232   int jresult ;
59233   int result;
59234
59235   {
59236     try {
59237       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
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_POSITION_get() {
59263   int jresult ;
59264   int result;
59265
59266   {
59267     try {
59268       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
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 int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59294   int jresult ;
59295   int result;
59296
59297   {
59298     try {
59299       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
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 = (int)result;
59320   return jresult;
59321 }
59322
59323
59324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59325   int jresult ;
59326   int result;
59327
59328   {
59329     try {
59330       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59331     } catch (std::out_of_range& e) {
59332       {
59333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59334       };
59335     } catch (std::exception& e) {
59336       {
59337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59338       };
59339     } catch (Dali::DaliException e) {
59340       {
59341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59342       };
59343     } catch (...) {
59344       {
59345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59346       };
59347     }
59348   }
59349
59350   jresult = (int)result;
59351   return jresult;
59352 }
59353
59354
59355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59356   int jresult ;
59357   int result;
59358
59359   {
59360     try {
59361       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59362     } catch (std::out_of_range& e) {
59363       {
59364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59365       };
59366     } catch (std::exception& e) {
59367       {
59368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59369       };
59370     } catch (Dali::DaliException e) {
59371       {
59372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59373       };
59374     } catch (...) {
59375       {
59376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59377       };
59378     }
59379   }
59380
59381   jresult = (int)result;
59382   return jresult;
59383 }
59384
59385
59386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59387   int jresult ;
59388   int result;
59389
59390   {
59391     try {
59392       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59393     } catch (std::out_of_range& e) {
59394       {
59395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59396       };
59397     } catch (std::exception& e) {
59398       {
59399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59400       };
59401     } catch (Dali::DaliException e) {
59402       {
59403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59404       };
59405     } catch (...) {
59406       {
59407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59408       };
59409     }
59410   }
59411
59412   jresult = (int)result;
59413   return jresult;
59414 }
59415
59416
59417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59418   int jresult ;
59419   int result;
59420
59421   {
59422     try {
59423       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59424     } catch (std::out_of_range& e) {
59425       {
59426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59427       };
59428     } catch (std::exception& e) {
59429       {
59430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59431       };
59432     } catch (Dali::DaliException e) {
59433       {
59434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59435       };
59436     } catch (...) {
59437       {
59438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59439       };
59440     }
59441   }
59442
59443   jresult = (int)result;
59444   return jresult;
59445 }
59446
59447
59448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59449   int jresult ;
59450   int result;
59451
59452   {
59453     try {
59454       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59455     } catch (std::out_of_range& e) {
59456       {
59457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59458       };
59459     } catch (std::exception& e) {
59460       {
59461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59462       };
59463     } catch (Dali::DaliException e) {
59464       {
59465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59466       };
59467     } catch (...) {
59468       {
59469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59470       };
59471     }
59472   }
59473
59474   jresult = (int)result;
59475   return jresult;
59476 }
59477
59478
59479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59480   int jresult ;
59481   int result;
59482
59483   {
59484     try {
59485       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59486     } catch (std::out_of_range& e) {
59487       {
59488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59489       };
59490     } catch (std::exception& e) {
59491       {
59492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59493       };
59494     } catch (Dali::DaliException e) {
59495       {
59496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59497       };
59498     } catch (...) {
59499       {
59500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59501       };
59502     }
59503   }
59504
59505   jresult = (int)result;
59506   return jresult;
59507 }
59508
59509
59510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59511   int jresult ;
59512   int result;
59513
59514   {
59515     try {
59516       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59517     } catch (std::out_of_range& e) {
59518       {
59519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59520       };
59521     } catch (std::exception& e) {
59522       {
59523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59524       };
59525     } catch (Dali::DaliException e) {
59526       {
59527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59528       };
59529     } catch (...) {
59530       {
59531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59532       };
59533     }
59534   }
59535
59536   jresult = (int)result;
59537   return jresult;
59538 }
59539
59540
59541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59542   void * jresult ;
59543   Dali::Toolkit::Control result;
59544
59545   {
59546     try {
59547       result = Dali::Toolkit::Internal::Control::New();
59548     } catch (std::out_of_range& e) {
59549       {
59550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59551       };
59552     } catch (std::exception& e) {
59553       {
59554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59555       };
59556     } catch (Dali::DaliException e) {
59557       {
59558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59559       };
59560     } catch (...) {
59561       {
59562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59563       };
59564     }
59565   }
59566
59567   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59568   return jresult;
59569 }
59570
59571
59572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59573   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59574   std::string *arg2 = 0 ;
59575
59576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59577   if (!jarg2) {
59578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59579     return ;
59580   }
59581   std::string arg2_str(jarg2);
59582   arg2 = &arg2_str;
59583   {
59584     try {
59585       (arg1)->SetStyleName((std::string const &)*arg2);
59586     } catch (std::out_of_range& e) {
59587       {
59588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59589       };
59590     } catch (std::exception& e) {
59591       {
59592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59593       };
59594     } catch (Dali::DaliException e) {
59595       {
59596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59597       };
59598     } catch (...) {
59599       {
59600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59601       };
59602     }
59603   }
59604
59605
59606   //argout typemap for const std::string&
59607
59608 }
59609
59610
59611 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59612   char * jresult ;
59613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59614   std::string *result = 0 ;
59615
59616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59617   {
59618     try {
59619       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59620     } catch (std::out_of_range& e) {
59621       {
59622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59623       };
59624     } catch (std::exception& e) {
59625       {
59626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59627       };
59628     } catch (Dali::DaliException e) {
59629       {
59630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59631       };
59632     } catch (...) {
59633       {
59634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59635       };
59636     }
59637   }
59638
59639   jresult = SWIG_csharp_string_callback(result->c_str());
59640   return jresult;
59641 }
59642
59643
59644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59646   Dali::Vector4 *arg2 = 0 ;
59647
59648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59649   arg2 = (Dali::Vector4 *)jarg2;
59650   if (!arg2) {
59651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59652     return ;
59653   }
59654   {
59655     try {
59656       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59657     } catch (std::out_of_range& e) {
59658       {
59659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59660       };
59661     } catch (std::exception& e) {
59662       {
59663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59664       };
59665     } catch (Dali::DaliException e) {
59666       {
59667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59668       };
59669     } catch (...) {
59670       {
59671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59672       };
59673     }
59674   }
59675
59676 }
59677
59678
59679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59680   void * jresult ;
59681   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59682   Dali::Vector4 result;
59683
59684   arg1 = (Dali::Handle *)jarg1;
59685   {
59686     try {
59687       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59688       if (resultMap)
59689       {
59690         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59691         if(type && type->Get<int>() == Visual::COLOR )
59692         {
59693           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59694           if (value)
59695           {
59696             result = value->Get<Vector4>();
59697           }
59698         }
59699       }
59700     } catch (std::out_of_range& e) {
59701       {
59702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59703       };
59704     } catch (std::exception& e) {
59705       {
59706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59707       };
59708     } catch (Dali::DaliException e) {
59709       {
59710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59711       };
59712     } catch (...) {
59713       {
59714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59715       };
59716     }
59717   }
59718
59719   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59720   return jresult;
59721 }
59722
59723
59724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59725   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59726   Dali::Property::Map *arg2 = 0 ;
59727
59728   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59729   arg2 = (Dali::Property::Map *)jarg2;
59730   if (!arg2) {
59731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59732     return ;
59733   }
59734   {
59735     try {
59736       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59737     } catch (std::out_of_range& e) {
59738       {
59739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59740       };
59741     } catch (std::exception& e) {
59742       {
59743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59744       };
59745     } catch (Dali::DaliException e) {
59746       {
59747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59748       };
59749     } catch (...) {
59750       {
59751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59752       };
59753     }
59754   }
59755
59756 }
59757
59758
59759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59761
59762   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59763   {
59764     try {
59765       (arg1)->ClearBackground();
59766     } catch (std::out_of_range& e) {
59767       {
59768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59769       };
59770     } catch (std::exception& e) {
59771       {
59772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59773       };
59774     } catch (Dali::DaliException e) {
59775       {
59776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59777       };
59778     } catch (...) {
59779       {
59780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59781       };
59782     }
59783   }
59784
59785 }
59786
59787
59788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59790   Dali::Gesture::Type arg2 ;
59791
59792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59793   arg2 = (Dali::Gesture::Type)jarg2;
59794   {
59795     try {
59796       (arg1)->EnableGestureDetection(arg2);
59797     } catch (std::out_of_range& e) {
59798       {
59799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59800       };
59801     } catch (std::exception& e) {
59802       {
59803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59804       };
59805     } catch (Dali::DaliException e) {
59806       {
59807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59808       };
59809     } catch (...) {
59810       {
59811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59812       };
59813     }
59814   }
59815
59816 }
59817
59818
59819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59821   Dali::Gesture::Type arg2 ;
59822
59823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59824   arg2 = (Dali::Gesture::Type)jarg2;
59825   {
59826     try {
59827       (arg1)->DisableGestureDetection(arg2);
59828     } catch (std::out_of_range& e) {
59829       {
59830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59831       };
59832     } catch (std::exception& e) {
59833       {
59834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59835       };
59836     } catch (Dali::DaliException e) {
59837       {
59838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59839       };
59840     } catch (...) {
59841       {
59842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59843       };
59844     }
59845   }
59846
59847 }
59848
59849
59850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59851   void * jresult ;
59852   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59853   Dali::PinchGestureDetector result;
59854
59855   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59856   {
59857     try {
59858       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59859     } catch (std::out_of_range& e) {
59860       {
59861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59862       };
59863     } catch (std::exception& e) {
59864       {
59865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59866       };
59867     } catch (Dali::DaliException e) {
59868       {
59869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59870       };
59871     } catch (...) {
59872       {
59873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59874       };
59875     }
59876   }
59877
59878   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59879   return jresult;
59880 }
59881
59882
59883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59884   void * jresult ;
59885   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59886   Dali::PanGestureDetector result;
59887
59888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59889   {
59890     try {
59891       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59892     } catch (std::out_of_range& e) {
59893       {
59894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59895       };
59896     } catch (std::exception& e) {
59897       {
59898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59899       };
59900     } catch (Dali::DaliException e) {
59901       {
59902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59903       };
59904     } catch (...) {
59905       {
59906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59907       };
59908     }
59909   }
59910
59911   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59912   return jresult;
59913 }
59914
59915
59916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59917   void * jresult ;
59918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59919   Dali::TapGestureDetector result;
59920
59921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59922   {
59923     try {
59924       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59925     } catch (std::out_of_range& e) {
59926       {
59927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59928       };
59929     } catch (std::exception& e) {
59930       {
59931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59932       };
59933     } catch (Dali::DaliException e) {
59934       {
59935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59936       };
59937     } catch (...) {
59938       {
59939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59940       };
59941     }
59942   }
59943
59944   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59945   return jresult;
59946 }
59947
59948
59949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59950   void * jresult ;
59951   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59952   Dali::LongPressGestureDetector result;
59953
59954   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59955   {
59956     try {
59957       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59958     } catch (std::out_of_range& e) {
59959       {
59960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59961       };
59962     } catch (std::exception& e) {
59963       {
59964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59965       };
59966     } catch (Dali::DaliException e) {
59967       {
59968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59969       };
59970     } catch (...) {
59971       {
59972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59973       };
59974     }
59975   }
59976
59977   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59978   return jresult;
59979 }
59980
59981
59982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59984   bool arg2 ;
59985
59986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59987   arg2 = jarg2 ? true : false;
59988   {
59989     try {
59990       (arg1)->SetKeyboardNavigationSupport(arg2);
59991     } catch (std::out_of_range& e) {
59992       {
59993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59994       };
59995     } catch (std::exception& e) {
59996       {
59997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59998       };
59999     } catch (Dali::DaliException e) {
60000       {
60001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60002       };
60003     } catch (...) {
60004       {
60005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60006       };
60007     }
60008   }
60009
60010 }
60011
60012
60013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60014   unsigned int jresult ;
60015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60016   bool result;
60017
60018   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60019   {
60020     try {
60021       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60022     } catch (std::out_of_range& e) {
60023       {
60024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60025       };
60026     } catch (std::exception& e) {
60027       {
60028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60029       };
60030     } catch (Dali::DaliException e) {
60031       {
60032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60033       };
60034     } catch (...) {
60035       {
60036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60037       };
60038     }
60039   }
60040
60041   jresult = result;
60042   return jresult;
60043 }
60044
60045
60046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
60047   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60048
60049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60050   {
60051     try {
60052       (arg1)->SetKeyInputFocus();
60053     } catch (std::out_of_range& e) {
60054       {
60055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60056       };
60057     } catch (std::exception& e) {
60058       {
60059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60060       };
60061     } catch (Dali::DaliException e) {
60062       {
60063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60064       };
60065     } catch (...) {
60066       {
60067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60068       };
60069     }
60070   }
60071
60072 }
60073
60074
60075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60076   unsigned int jresult ;
60077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60078   bool result;
60079
60080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60081   {
60082     try {
60083       result = (bool)(arg1)->HasKeyInputFocus();
60084     } catch (std::out_of_range& e) {
60085       {
60086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60087       };
60088     } catch (std::exception& e) {
60089       {
60090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60091       };
60092     } catch (Dali::DaliException e) {
60093       {
60094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60095       };
60096     } catch (...) {
60097       {
60098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60099       };
60100     }
60101   }
60102
60103   jresult = result;
60104   return jresult;
60105 }
60106
60107
60108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60109   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60110
60111   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60112   {
60113     try {
60114       (arg1)->ClearKeyInputFocus();
60115     } catch (std::out_of_range& e) {
60116       {
60117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60118       };
60119     } catch (std::exception& e) {
60120       {
60121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60122       };
60123     } catch (Dali::DaliException e) {
60124       {
60125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60126       };
60127     } catch (...) {
60128       {
60129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60130       };
60131     }
60132   }
60133
60134 }
60135
60136
60137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60138   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60139   bool arg2 ;
60140
60141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60142   arg2 = jarg2 ? true : false;
60143   {
60144     try {
60145       (arg1)->SetAsKeyboardFocusGroup(arg2);
60146     } catch (std::out_of_range& e) {
60147       {
60148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60149       };
60150     } catch (std::exception& e) {
60151       {
60152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60153       };
60154     } catch (Dali::DaliException e) {
60155       {
60156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60157       };
60158     } catch (...) {
60159       {
60160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60161       };
60162     }
60163   }
60164
60165 }
60166
60167
60168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60169   unsigned int jresult ;
60170   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60171   bool result;
60172
60173   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60174   {
60175     try {
60176       result = (bool)(arg1)->IsKeyboardFocusGroup();
60177     } catch (std::out_of_range& e) {
60178       {
60179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60180       };
60181     } catch (std::exception& e) {
60182       {
60183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60184       };
60185     } catch (Dali::DaliException e) {
60186       {
60187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60188       };
60189     } catch (...) {
60190       {
60191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60192       };
60193     }
60194   }
60195
60196   jresult = result;
60197   return jresult;
60198 }
60199
60200
60201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60202   void * jresult ;
60203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60204   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60205
60206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60207   {
60208     try {
60209       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60210     } catch (std::out_of_range& e) {
60211       {
60212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60213       };
60214     } catch (std::exception& e) {
60215       {
60216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60217       };
60218     } catch (Dali::DaliException e) {
60219       {
60220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60221       };
60222     } catch (...) {
60223       {
60224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60225       };
60226     }
60227   }
60228
60229   jresult = (void *)result;
60230   return jresult;
60231 }
60232
60233
60234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60235   void * jresult ;
60236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60237   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60238
60239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60240   {
60241     try {
60242       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60243     } catch (std::out_of_range& e) {
60244       {
60245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60246       };
60247     } catch (std::exception& e) {
60248       {
60249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60250       };
60251     } catch (Dali::DaliException e) {
60252       {
60253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60254       };
60255     } catch (...) {
60256       {
60257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60258       };
60259     }
60260   }
60261
60262   jresult = (void *)result;
60263   return jresult;
60264 }
60265
60266
60267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60268   void * jresult ;
60269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60270   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60271
60272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60273   {
60274     try {
60275       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60276     } catch (std::out_of_range& e) {
60277       {
60278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60279       };
60280     } catch (std::exception& e) {
60281       {
60282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60283       };
60284     } catch (Dali::DaliException e) {
60285       {
60286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60287       };
60288     } catch (...) {
60289       {
60290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60291       };
60292     }
60293   }
60294
60295   jresult = (void *)result;
60296   return jresult;
60297 }
60298
60299
60300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60301   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60302   int arg2 ;
60303   SwigDirector_ViewImpl *darg = 0;
60304
60305   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60306   arg2 = (int)jarg2;
60307   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60308   if(!darg) {
60309     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60310     return;
60311   }
60312   {
60313     try {
60314       if(darg) {
60315         (darg)->OnStageConnection(arg2);
60316       }
60317     } catch (std::out_of_range& e) {
60318       {
60319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60320       };
60321     } catch (std::exception& e) {
60322       {
60323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60324       };
60325     } catch (Dali::DaliException e) {
60326       {
60327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60328       };
60329     } catch (...) {
60330       {
60331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60332       };
60333     }
60334   }
60335
60336 }
60337
60338
60339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60340   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60341   int arg2 ;
60342   SwigDirector_ViewImpl *darg = 0;
60343
60344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60345   arg2 = (int)jarg2;
60346   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60347   if(!darg) {
60348     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60349     return;
60350   }
60351   {
60352     try {
60353       if(darg) {
60354         (darg)->OnStageConnectionSwigPublic(arg2);
60355       }
60356     } catch (std::out_of_range& e) {
60357       {
60358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60359       };
60360     } catch (std::exception& e) {
60361       {
60362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60363       };
60364     } catch (Dali::DaliException e) {
60365       {
60366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60367       };
60368     } catch (...) {
60369       {
60370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60371       };
60372     }
60373   }
60374
60375 }
60376
60377
60378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60380   SwigDirector_ViewImpl *darg = 0;
60381
60382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60383   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60384   if(!darg) {
60385     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60386     return;
60387   }
60388   {
60389     try {
60390       if(darg) {
60391         (darg)->OnStageDisconnection();
60392       }
60393     } catch (std::out_of_range& e) {
60394       {
60395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60396       };
60397     } catch (std::exception& e) {
60398       {
60399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60400       };
60401     } catch (Dali::DaliException e) {
60402       {
60403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60404       };
60405     } catch (...) {
60406       {
60407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60408       };
60409     }
60410   }
60411
60412 }
60413
60414
60415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60416   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60417   SwigDirector_ViewImpl *darg = 0;
60418
60419   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60420   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60421   if(!darg) {
60422     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60423     return;
60424   }
60425   {
60426     try {
60427       if(darg) {
60428         (darg)->OnStageDisconnectionSwigPublic();
60429       }
60430     } catch (std::out_of_range& e) {
60431       {
60432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60433       };
60434     } catch (std::exception& e) {
60435       {
60436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60437       };
60438     } catch (Dali::DaliException e) {
60439       {
60440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60441       };
60442     } catch (...) {
60443       {
60444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60445       };
60446     }
60447   }
60448
60449 }
60450
60451
60452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60453   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60454   Dali::Actor *arg2 = 0 ;
60455   SwigDirector_ViewImpl *darg = 0;
60456
60457   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60458   arg2 = (Dali::Actor *)jarg2;
60459   if (!arg2) {
60460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60461     return ;
60462   }
60463   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60464   if(!darg) {
60465     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60466     return;
60467   }
60468   {
60469     try {
60470       if(darg) {
60471         (darg)->OnChildAdd(*arg2);
60472       }
60473     } catch (std::out_of_range& e) {
60474       {
60475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60476       };
60477     } catch (std::exception& e) {
60478       {
60479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60480       };
60481     } catch (Dali::DaliException e) {
60482       {
60483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60484       };
60485     } catch (...) {
60486       {
60487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60488       };
60489     }
60490   }
60491
60492 }
60493
60494
60495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60496   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60497   Dali::Actor *arg2 = 0 ;
60498   SwigDirector_ViewImpl *darg = 0;
60499
60500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60501   arg2 = (Dali::Actor *)jarg2;
60502   if (!arg2) {
60503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60504     return ;
60505   }
60506   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60507   if(!darg) {
60508     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60509     return;
60510   }
60511   {
60512     try {
60513       if(darg) {
60514           (darg)->OnChildAddSwigPublic(*arg2);
60515       }
60516     } catch (std::out_of_range& e) {
60517       {
60518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60519       };
60520     } catch (std::exception& e) {
60521       {
60522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60523       };
60524     } catch (Dali::DaliException e) {
60525       {
60526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60527       };
60528     } catch (...) {
60529       {
60530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60531       };
60532     }
60533   }
60534
60535 }
60536
60537
60538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60539   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60540   Dali::Actor *arg2 = 0 ;
60541   SwigDirector_ViewImpl *darg = 0;
60542
60543   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60544   arg2 = (Dali::Actor *)jarg2;
60545   if (!arg2) {
60546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60547     return ;
60548   }
60549   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60550   if(!darg) {
60551     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60552     return;
60553   }
60554   {
60555     try {
60556       if(darg) {
60557         (darg)->OnChildRemove(*arg2);
60558       }
60559     } catch (std::out_of_range& e) {
60560       {
60561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60562       };
60563     } catch (std::exception& e) {
60564       {
60565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60566       };
60567     } catch (Dali::DaliException e) {
60568       {
60569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60570       };
60571     } catch (...) {
60572       {
60573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60574       };
60575     }
60576   }
60577
60578 }
60579
60580
60581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60583   Dali::Actor *arg2 = 0 ;
60584   SwigDirector_ViewImpl *darg = 0;
60585
60586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60587   arg2 = (Dali::Actor *)jarg2;
60588   if (!arg2) {
60589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60590     return ;
60591   }
60592   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60593   if(!darg) {
60594     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60595     return;
60596   }
60597   {
60598     try {
60599       if(darg) {
60600         (darg)->OnChildRemoveSwigPublic(*arg2);
60601       }
60602     } catch (std::out_of_range& e) {
60603       {
60604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60605       };
60606     } catch (std::exception& e) {
60607       {
60608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60609       };
60610     } catch (Dali::DaliException e) {
60611       {
60612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60613       };
60614     } catch (...) {
60615       {
60616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60617       };
60618     }
60619   }
60620
60621 }
60622
60623
60624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60626   Dali::Property::Index arg2 ;
60627   Dali::Property::Value arg3 ;
60628   Dali::Property::Value *argp3 ;
60629   SwigDirector_ViewImpl *darg = 0;
60630
60631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60632   arg2 = (Dali::Property::Index)jarg2;
60633   argp3 = (Dali::Property::Value *)jarg3;
60634   if (!argp3) {
60635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60636     return ;
60637   }
60638   arg3 = *argp3;
60639   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60640   if (!darg) {
60641     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60642     return;
60643   }
60644   {
60645     try {
60646       (darg)->OnPropertySet(arg2,arg3);
60647     } catch (std::out_of_range& e) {
60648       {
60649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60650       };
60651     } catch (std::exception& e) {
60652       {
60653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60654       };
60655     } catch (Dali::DaliException e) {
60656       {
60657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60658       };
60659     } catch (...) {
60660       {
60661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60662       };
60663     }
60664   }
60665
60666 }
60667
60668
60669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60671   Dali::Property::Index arg2 ;
60672   Dali::Property::Value arg3 ;
60673   Dali::Property::Value *argp3 ;
60674   SwigDirector_ViewImpl *darg = 0;
60675
60676   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60677   arg2 = (Dali::Property::Index)jarg2;
60678   argp3 = (Dali::Property::Value *)jarg3;
60679   if (!argp3) {
60680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60681     return ;
60682   }
60683   arg3 = *argp3;
60684   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60685   if (!darg) {
60686     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60687     return;
60688   }
60689   {
60690     try {
60691       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60692     } catch (std::out_of_range& e) {
60693       {
60694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60695       };
60696     } catch (std::exception& e) {
60697       {
60698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60699       };
60700     } catch (Dali::DaliException e) {
60701       {
60702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60703       };
60704     } catch (...) {
60705       {
60706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60707       };
60708     }
60709   }
60710
60711 }
60712
60713
60714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60716   Dali::Vector3 *arg2 = 0 ;
60717   SwigDirector_ViewImpl *darg = 0;
60718
60719   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60720   arg2 = (Dali::Vector3 *)jarg2;
60721   if (!arg2) {
60722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60723     return ;
60724   }
60725   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60726   if (!darg) {
60727     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60728     return;
60729   }
60730   {
60731     try {
60732       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60733     } catch (std::out_of_range& e) {
60734       {
60735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60736       };
60737     } catch (std::exception& e) {
60738       {
60739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60740       };
60741     } catch (Dali::DaliException e) {
60742       {
60743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60744       };
60745     } catch (...) {
60746       {
60747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60748       };
60749     }
60750   }
60751
60752 }
60753
60754
60755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60756   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60757   Dali::Vector3 *arg2 = 0 ;
60758   SwigDirector_ViewImpl *darg = 0;
60759
60760   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60761   arg2 = (Dali::Vector3 *)jarg2;
60762   if (!arg2) {
60763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60764     return ;
60765   }
60766   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60767   if (!darg) {
60768     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60769     return;
60770   }
60771   {
60772     try {
60773       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60774     } catch (std::out_of_range& e) {
60775       {
60776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60777       };
60778     } catch (std::exception& e) {
60779       {
60780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60781       };
60782     } catch (Dali::DaliException e) {
60783       {
60784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60785       };
60786     } catch (...) {
60787       {
60788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60789       };
60790     }
60791   }
60792
60793 }
60794
60795
60796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60797   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60798   Dali::Animation *arg2 = 0 ;
60799   Dali::Vector3 *arg3 = 0 ;
60800   SwigDirector_ViewImpl *darg = 0;
60801
60802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60803   arg2 = (Dali::Animation *)jarg2;
60804   if (!arg2) {
60805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60806     return ;
60807   }
60808   arg3 = (Dali::Vector3 *)jarg3;
60809   if (!arg3) {
60810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60811     return ;
60812   }
60813   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60814   if (!darg) {
60815     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60816     return;
60817   }
60818   {
60819     try {
60820       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60821     } catch (std::out_of_range& e) {
60822       {
60823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60824       };
60825     } catch (std::exception& e) {
60826       {
60827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60828       };
60829     } catch (Dali::DaliException e) {
60830       {
60831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60832       };
60833     } catch (...) {
60834       {
60835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60836       };
60837     }
60838   }
60839
60840 }
60841
60842
60843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60845   Dali::Animation *arg2 = 0 ;
60846   Dali::Vector3 *arg3 = 0 ;
60847   SwigDirector_ViewImpl *darg = 0;
60848
60849   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60850   arg2 = (Dali::Animation *)jarg2;
60851   if (!arg2) {
60852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60853     return ;
60854   }
60855   arg3 = (Dali::Vector3 *)jarg3;
60856   if (!arg3) {
60857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60858     return ;
60859   }
60860   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60861   if (!darg) {
60862     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60863     return;
60864   }
60865   {
60866     try {
60867       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60868     } catch (std::out_of_range& e) {
60869       {
60870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60871       };
60872     } catch (std::exception& e) {
60873       {
60874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60875       };
60876     } catch (Dali::DaliException e) {
60877       {
60878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60879       };
60880     } catch (...) {
60881       {
60882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60883       };
60884     }
60885   }
60886
60887 }
60888
60889
60890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60891   unsigned int jresult ;
60892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60893   Dali::TouchEvent *arg2 = 0 ;
60894   SwigDirector_ViewImpl *darg = 0;
60895   bool result;
60896
60897   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60898   arg2 = (Dali::TouchEvent *)jarg2;
60899   if (!arg2) {
60900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60901     return 0;
60902   }
60903   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60904   if (!darg) {
60905     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60906     return 0;
60907   }
60908   {
60909     try {
60910       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60911     } catch (std::out_of_range& e) {
60912       {
60913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60914       };
60915     } catch (std::exception& e) {
60916       {
60917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60918       };
60919     } catch (Dali::DaliException e) {
60920       {
60921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60922       };
60923     } catch (...) {
60924       {
60925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60926       };
60927     }
60928   }
60929
60930   jresult = result;
60931   return jresult;
60932 }
60933
60934
60935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60936   unsigned int jresult ;
60937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60938   Dali::TouchEvent *arg2 = 0 ;
60939   SwigDirector_ViewImpl *darg = 0;
60940   bool result;
60941
60942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60943   arg2 = (Dali::TouchEvent *)jarg2;
60944   if (!arg2) {
60945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60946     return 0;
60947   }
60948   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60949   if (!darg) {
60950     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60951     return 0;
60952   }
60953   {
60954     try {
60955       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60956     } catch (std::out_of_range& e) {
60957       {
60958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60959       };
60960     } catch (std::exception& e) {
60961       {
60962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60963       };
60964     } catch (Dali::DaliException e) {
60965       {
60966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60967       };
60968     } catch (...) {
60969       {
60970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60971       };
60972     }
60973   }
60974
60975   jresult = result;
60976   return jresult;
60977 }
60978
60979
60980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60981   unsigned int jresult ;
60982   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60983   Dali::HoverEvent *arg2 = 0 ;
60984   SwigDirector_ViewImpl *darg = 0;
60985   bool result;
60986
60987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60988   arg2 = (Dali::HoverEvent *)jarg2;
60989   if (!arg2) {
60990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60991     return 0;
60992   }
60993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60994   if (!darg) {
60995     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60996     return 0;
60997   }
60998   {
60999     try {
61000       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
61001     } catch (std::out_of_range& e) {
61002       {
61003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61004       };
61005     } catch (std::exception& e) {
61006       {
61007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61008       };
61009     } catch (Dali::DaliException e) {
61010       {
61011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61012       };
61013     } catch (...) {
61014       {
61015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61016       };
61017     }
61018   }
61019
61020   jresult = result;
61021   return jresult;
61022 }
61023
61024
61025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61026   unsigned int jresult ;
61027   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61028   Dali::HoverEvent *arg2 = 0 ;
61029   SwigDirector_ViewImpl *darg = 0;
61030   bool result;
61031
61032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61033   arg2 = (Dali::HoverEvent *)jarg2;
61034   if (!arg2) {
61035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61036     return 0;
61037   }
61038   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61039   if (!darg) {
61040     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61041     return 0;
61042   }
61043   {
61044     try {
61045       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
61046     } catch (std::out_of_range& e) {
61047       {
61048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61049       };
61050     } catch (std::exception& e) {
61051       {
61052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61053       };
61054     } catch (Dali::DaliException e) {
61055       {
61056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61057       };
61058     } catch (...) {
61059       {
61060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61061       };
61062     }
61063   }
61064
61065   jresult = result;
61066   return jresult;
61067 }
61068
61069
61070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61071   unsigned int jresult ;
61072   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61073   Dali::KeyEvent *arg2 = 0 ;
61074   SwigDirector_ViewImpl *darg = 0;
61075   bool result;
61076
61077   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61078   arg2 = (Dali::KeyEvent *)jarg2;
61079   if (!arg2) {
61080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61081     return 0;
61082   }
61083   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61084   if (!darg) {
61085     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61086     return 0;
61087   }
61088   {
61089     try {
61090       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61091     } catch (std::out_of_range& e) {
61092       {
61093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61094       };
61095     } catch (std::exception& e) {
61096       {
61097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61098       };
61099     } catch (Dali::DaliException e) {
61100       {
61101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61102       };
61103     } catch (...) {
61104       {
61105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61106       };
61107     }
61108   }
61109
61110   jresult = result;
61111   return jresult;
61112 }
61113
61114
61115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61116   unsigned int jresult ;
61117   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61118   Dali::KeyEvent *arg2 = 0 ;
61119   SwigDirector_ViewImpl *darg = 0;
61120   bool result;
61121
61122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61123   arg2 = (Dali::KeyEvent *)jarg2;
61124   if (!arg2) {
61125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61126     return 0;
61127   }
61128   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61129   if (!darg) {
61130     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61131     return 0;
61132   }
61133   {
61134     try {
61135       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61136     } catch (std::out_of_range& e) {
61137       {
61138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61139       };
61140     } catch (std::exception& e) {
61141       {
61142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61143       };
61144     } catch (Dali::DaliException e) {
61145       {
61146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61147       };
61148     } catch (...) {
61149       {
61150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61151       };
61152     }
61153   }
61154
61155   jresult = result;
61156   return jresult;
61157 }
61158
61159
61160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61161   unsigned int jresult ;
61162   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61163   Dali::WheelEvent *arg2 = 0 ;
61164   SwigDirector_ViewImpl *darg = 0;
61165   bool result;
61166
61167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61168   arg2 = (Dali::WheelEvent *)jarg2;
61169   if (!arg2) {
61170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61171     return 0;
61172   }
61173   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61174   if (!darg) {
61175     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61176     return 0;
61177   }
61178   {
61179     try {
61180       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61181     } catch (std::out_of_range& e) {
61182       {
61183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61184       };
61185     } catch (std::exception& e) {
61186       {
61187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61188       };
61189     } catch (Dali::DaliException e) {
61190       {
61191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61192       };
61193     } catch (...) {
61194       {
61195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61196       };
61197     }
61198   }
61199
61200   jresult = result;
61201   return jresult;
61202 }
61203
61204
61205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61206   unsigned int jresult ;
61207   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61208   Dali::WheelEvent *arg2 = 0 ;
61209   SwigDirector_ViewImpl *darg = 0;
61210   bool result;
61211
61212   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61213   arg2 = (Dali::WheelEvent *)jarg2;
61214   if (!arg2) {
61215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61216     return 0;
61217   }
61218   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61219   if (!darg) {
61220     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61221     return 0;
61222   }
61223   {
61224     try {
61225       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61226     } catch (std::out_of_range& e) {
61227       {
61228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61229       };
61230     } catch (std::exception& e) {
61231       {
61232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61233       };
61234     } catch (Dali::DaliException e) {
61235       {
61236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61237       };
61238     } catch (...) {
61239       {
61240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61241       };
61242     }
61243   }
61244
61245   jresult = result;
61246   return jresult;
61247 }
61248
61249
61250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61252   Dali::Vector2 *arg2 = 0 ;
61253   Dali::RelayoutContainer *arg3 = 0 ;
61254   SwigDirector_ViewImpl *darg = 0;
61255
61256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61257   arg2 = (Dali::Vector2 *)jarg2;
61258   if (!arg2) {
61259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61260     return ;
61261   }
61262   arg3 = (Dali::RelayoutContainer *)jarg3;
61263   if (!arg3) {
61264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61265     return ;
61266   }
61267   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61268   if (!darg) {
61269     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61270     return;
61271   }
61272   {
61273     try {
61274       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61275     } catch (std::out_of_range& e) {
61276       {
61277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61278       };
61279     } catch (std::exception& e) {
61280       {
61281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61282       };
61283     } catch (Dali::DaliException e) {
61284       {
61285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61286       };
61287     } catch (...) {
61288       {
61289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61290       };
61291     }
61292   }
61293
61294 }
61295
61296
61297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61298   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61299   Dali::Vector2 *arg2 = 0 ;
61300   Dali::RelayoutContainer *arg3 = 0 ;
61301   SwigDirector_ViewImpl *darg = 0;
61302
61303   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61304   arg2 = (Dali::Vector2 *)jarg2;
61305   if (!arg2) {
61306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61307     return ;
61308   }
61309   arg3 = (Dali::RelayoutContainer *)jarg3;
61310   if (!arg3) {
61311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61312     return ;
61313   }
61314   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61315   if (!darg) {
61316     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61317     return;
61318   }
61319   {
61320     try {
61321       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61322     } catch (std::out_of_range& e) {
61323       {
61324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61325       };
61326     } catch (std::exception& e) {
61327       {
61328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61329       };
61330     } catch (Dali::DaliException e) {
61331       {
61332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61333       };
61334     } catch (...) {
61335       {
61336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61337       };
61338     }
61339   }
61340
61341 }
61342
61343
61344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61346   Dali::ResizePolicy::Type arg2 ;
61347   Dali::Dimension::Type arg3 ;
61348   SwigDirector_ViewImpl *darg = 0;
61349
61350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61351   arg2 = (Dali::ResizePolicy::Type)jarg2;
61352   arg3 = (Dali::Dimension::Type)jarg3;
61353   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61354   if (!darg) {
61355     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61356     return;
61357   }
61358   {
61359     try {
61360       (darg)->OnSetResizePolicy(arg2,arg3);
61361     } catch (std::out_of_range& e) {
61362       {
61363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61364       };
61365     } catch (std::exception& e) {
61366       {
61367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61368       };
61369     } catch (Dali::DaliException e) {
61370       {
61371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61372       };
61373     } catch (...) {
61374       {
61375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61376       };
61377     }
61378   }
61379
61380 }
61381
61382
61383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61384   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61385   Dali::ResizePolicy::Type arg2 ;
61386   Dali::Dimension::Type arg3 ;
61387   SwigDirector_ViewImpl *darg = 0;
61388
61389   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61390   arg2 = (Dali::ResizePolicy::Type)jarg2;
61391   arg3 = (Dali::Dimension::Type)jarg3;
61392   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61393   if (!darg) {
61394     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61395     return;
61396   }
61397   {
61398     try {
61399       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61400     } catch (std::out_of_range& e) {
61401       {
61402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61403       };
61404     } catch (std::exception& e) {
61405       {
61406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61407       };
61408     } catch (Dali::DaliException e) {
61409       {
61410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61411       };
61412     } catch (...) {
61413       {
61414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61415       };
61416     }
61417   }
61418
61419 }
61420
61421
61422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61423   void * jresult ;
61424   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61425   SwigDirector_ViewImpl *darg = 0;
61426   Dali::Vector3 result;
61427
61428   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61429   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61430   if (!darg) {
61431     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61432     return 0;
61433   }
61434   {
61435     try {
61436       result = (darg)->GetNaturalSize();
61437     } catch (std::out_of_range& e) {
61438       {
61439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61440       };
61441     } catch (std::exception& e) {
61442       {
61443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61444       };
61445     } catch (Dali::DaliException e) {
61446       {
61447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61448       };
61449     } catch (...) {
61450       {
61451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61452       };
61453     }
61454   }
61455
61456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61457   return jresult;
61458 }
61459
61460
61461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61462   void * jresult ;
61463   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61464   SwigDirector_ViewImpl *darg = 0;
61465   Dali::Vector3 result;
61466
61467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61468   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61469   if (!darg) {
61470     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61471     return 0;
61472   }
61473   {
61474     try {
61475       result = (darg)->GetNaturalSizeSwigPublic();
61476     } catch (std::out_of_range& e) {
61477       {
61478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61479       };
61480     } catch (std::exception& e) {
61481       {
61482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61483       };
61484     } catch (Dali::DaliException e) {
61485       {
61486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61487       };
61488     } catch (...) {
61489       {
61490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61491       };
61492     }
61493   }
61494
61495   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61496   return jresult;
61497 }
61498
61499
61500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61501   float jresult ;
61502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61503   Dali::Actor *arg2 = 0 ;
61504   Dali::Dimension::Type arg3 ;
61505   SwigDirector_ViewImpl *darg = 0;
61506   float result;
61507
61508   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61509   arg2 = (Dali::Actor *)jarg2;
61510   if (!arg2) {
61511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61512     return 0;
61513   }
61514   arg3 = (Dali::Dimension::Type)jarg3;
61515   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61516   if (!darg) {
61517     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61518     return 0;
61519   }
61520   {
61521     try {
61522       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61523     } catch (std::out_of_range& e) {
61524       {
61525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61526       };
61527     } catch (std::exception& e) {
61528       {
61529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61530       };
61531     } catch (Dali::DaliException e) {
61532       {
61533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61534       };
61535     } catch (...) {
61536       {
61537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61538       };
61539     }
61540   }
61541
61542   jresult = result;
61543   return jresult;
61544 }
61545
61546
61547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61548   float jresult ;
61549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61550   Dali::Actor *arg2 = 0 ;
61551   Dali::Dimension::Type arg3 ;
61552   SwigDirector_ViewImpl *darg = 0;
61553   float result;
61554
61555   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61556   arg2 = (Dali::Actor *)jarg2;
61557   if (!arg2) {
61558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61559     return 0;
61560   }
61561   arg3 = (Dali::Dimension::Type)jarg3;
61562   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61563   if (!darg) {
61564     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61565     return 0;
61566   }
61567   {
61568     try {
61569       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61570     } catch (std::out_of_range& e) {
61571       {
61572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61573       };
61574     } catch (std::exception& e) {
61575       {
61576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61577       };
61578     } catch (Dali::DaliException e) {
61579       {
61580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61581       };
61582     } catch (...) {
61583       {
61584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61585       };
61586     }
61587   }
61588
61589   jresult = result;
61590   return jresult;
61591 }
61592
61593
61594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61595   float jresult ;
61596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61597   float arg2 ;
61598   SwigDirector_ViewImpl *darg = 0;
61599   float result;
61600
61601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61602   arg2 = (float)jarg2;
61603   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61604   if (!darg) {
61605     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61606     return 0;
61607   }
61608   {
61609     try {
61610       result = (float)(darg)->GetHeightForWidth(arg2);
61611     } catch (std::out_of_range& e) {
61612       {
61613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61614       };
61615     } catch (std::exception& e) {
61616       {
61617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61618       };
61619     } catch (Dali::DaliException e) {
61620       {
61621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61622       };
61623     } catch (...) {
61624       {
61625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61626       };
61627     }
61628   }
61629
61630   jresult = result;
61631   return jresult;
61632 }
61633
61634
61635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61636   float jresult ;
61637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61638   float arg2 ;
61639   SwigDirector_ViewImpl *darg = 0;
61640   float result;
61641
61642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61643   arg2 = (float)jarg2;
61644   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61645   if (!darg) {
61646     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61647     return 0;
61648   }
61649   {
61650     try {
61651       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61652     } catch (std::out_of_range& e) {
61653       {
61654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61655       };
61656     } catch (std::exception& e) {
61657       {
61658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61659       };
61660     } catch (Dali::DaliException e) {
61661       {
61662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61663       };
61664     } catch (...) {
61665       {
61666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61667       };
61668     }
61669   }
61670
61671   jresult = result;
61672   return jresult;
61673 }
61674
61675
61676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61677   float jresult ;
61678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61679   float arg2 ;
61680   SwigDirector_ViewImpl *darg = 0;
61681   float result;
61682
61683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61684   arg2 = (float)jarg2;
61685   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61686   if (!darg) {
61687     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61688     return 0;
61689   }
61690   {
61691     try {
61692       result = (float)(darg)->GetWidthForHeight(arg2);
61693     } catch (std::out_of_range& e) {
61694       {
61695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61696       };
61697     } catch (std::exception& e) {
61698       {
61699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61700       };
61701     } catch (Dali::DaliException e) {
61702       {
61703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61704       };
61705     } catch (...) {
61706       {
61707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61708       };
61709     }
61710   }
61711
61712   jresult = result;
61713   return jresult;
61714 }
61715
61716
61717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61718   float jresult ;
61719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61720   float arg2 ;
61721   SwigDirector_ViewImpl *darg = 0;
61722   float result;
61723
61724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61725   arg2 = (float)jarg2;
61726   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61727   if (!darg) {
61728     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61729     return 0;
61730   }
61731   {
61732     try {
61733       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61734     } catch (std::out_of_range& e) {
61735       {
61736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61737       };
61738     } catch (std::exception& e) {
61739       {
61740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61741       };
61742     } catch (Dali::DaliException e) {
61743       {
61744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61745       };
61746     } catch (...) {
61747       {
61748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61749       };
61750     }
61751   }
61752
61753   jresult = result;
61754   return jresult;
61755 }
61756
61757
61758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61759   unsigned int jresult ;
61760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61761   Dali::Dimension::Type arg2 ;
61762   SwigDirector_ViewImpl *darg = 0;
61763   bool result;
61764
61765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61766   arg2 = (Dali::Dimension::Type)jarg2;
61767   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61768   if (!darg) {
61769     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61770     return 0;
61771   }
61772   {
61773     try {
61774       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61775     } catch (std::out_of_range& e) {
61776       {
61777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61778       };
61779     } catch (std::exception& e) {
61780       {
61781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61782       };
61783     } catch (Dali::DaliException e) {
61784       {
61785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61786       };
61787     } catch (...) {
61788       {
61789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61790       };
61791     }
61792   }
61793
61794   jresult = result;
61795   return jresult;
61796 }
61797
61798
61799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61800   unsigned int jresult ;
61801   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61802   Dali::Dimension::Type arg2 ;
61803   SwigDirector_ViewImpl *darg = 0;
61804   bool result;
61805
61806   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61807   arg2 = (Dali::Dimension::Type)jarg2;
61808   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61809   if (!darg) {
61810     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61811     return 0;
61812   }
61813   {
61814     try {
61815       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61816     } catch (std::out_of_range& e) {
61817       {
61818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61819       };
61820     } catch (std::exception& e) {
61821       {
61822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61823       };
61824     } catch (Dali::DaliException e) {
61825       {
61826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61827       };
61828     } catch (...) {
61829       {
61830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61831       };
61832     }
61833   }
61834
61835   jresult = result;
61836   return jresult;
61837 }
61838
61839
61840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61841   unsigned int jresult ;
61842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61843   SwigDirector_ViewImpl *darg = 0;
61844   bool result;
61845
61846   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61847   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61848   if (!darg) {
61849     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61850     return 0;
61851   }
61852   {
61853     try {
61854       result = (bool)(darg)->RelayoutDependentOnChildren();
61855     } catch (std::out_of_range& e) {
61856       {
61857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61858       };
61859     } catch (std::exception& e) {
61860       {
61861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61862       };
61863     } catch (Dali::DaliException e) {
61864       {
61865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61866       };
61867     } catch (...) {
61868       {
61869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61870       };
61871     }
61872   }
61873
61874   jresult = result;
61875   return jresult;
61876 }
61877
61878
61879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61880   unsigned int jresult ;
61881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61882   SwigDirector_ViewImpl *darg = 0;
61883   bool result;
61884
61885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61886   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61887   if (!darg) {
61888     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61889     return 0;
61890   }
61891   {
61892     try {
61893       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61894     } catch (std::out_of_range& e) {
61895       {
61896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61897       };
61898     } catch (std::exception& e) {
61899       {
61900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61901       };
61902     } catch (Dali::DaliException e) {
61903       {
61904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61905       };
61906     } catch (...) {
61907       {
61908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61909       };
61910     }
61911   }
61912
61913   jresult = result;
61914   return jresult;
61915 }
61916
61917
61918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61920   Dali::Dimension::Type arg2 ;
61921   SwigDirector_ViewImpl *darg = 0;
61922
61923   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61924   arg2 = (Dali::Dimension::Type)jarg2;
61925   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61926   if (!darg) {
61927     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61928     return;
61929   }
61930   {
61931     try {
61932       (darg)->OnCalculateRelayoutSize(arg2);
61933     } catch (std::out_of_range& e) {
61934       {
61935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61936       };
61937     } catch (std::exception& e) {
61938       {
61939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61940       };
61941     } catch (Dali::DaliException e) {
61942       {
61943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61944       };
61945     } catch (...) {
61946       {
61947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61948       };
61949     }
61950   }
61951
61952 }
61953
61954
61955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61956   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61957   Dali::Dimension::Type arg2 ;
61958   SwigDirector_ViewImpl *darg = 0;
61959
61960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61961   arg2 = (Dali::Dimension::Type)jarg2;
61962   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61963   if (!darg) {
61964     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61965     return;
61966   }
61967   {
61968     try {
61969       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61970     } catch (std::out_of_range& e) {
61971       {
61972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61973       };
61974     } catch (std::exception& e) {
61975       {
61976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61977       };
61978     } catch (Dali::DaliException e) {
61979       {
61980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61981       };
61982     } catch (...) {
61983       {
61984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61985       };
61986     }
61987   }
61988
61989 }
61990
61991
61992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61994   float arg2 ;
61995   Dali::Dimension::Type arg3 ;
61996   SwigDirector_ViewImpl *darg = 0;
61997
61998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61999   arg2 = (float)jarg2;
62000   arg3 = (Dali::Dimension::Type)jarg3;
62001   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62002   if (!darg) {
62003     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62004     return;
62005   }
62006   {
62007     try {
62008       (darg)->OnLayoutNegotiated(arg2,arg3);
62009     } catch (std::out_of_range& e) {
62010       {
62011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62012       };
62013     } catch (std::exception& e) {
62014       {
62015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62016       };
62017     } catch (Dali::DaliException e) {
62018       {
62019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62020       };
62021     } catch (...) {
62022       {
62023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62024       };
62025     }
62026   }
62027
62028 }
62029
62030
62031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
62032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62033   float arg2 ;
62034   Dali::Dimension::Type arg3 ;
62035   SwigDirector_ViewImpl *darg = 0;
62036
62037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62038   arg2 = (float)jarg2;
62039   arg3 = (Dali::Dimension::Type)jarg3;
62040   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62041   if (!darg) {
62042     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62043     return;
62044   }
62045   {
62046     try {
62047       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
62048     } catch (std::out_of_range& e) {
62049       {
62050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62051       };
62052     } catch (std::exception& e) {
62053       {
62054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62055       };
62056     } catch (Dali::DaliException e) {
62057       {
62058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62059       };
62060     } catch (...) {
62061       {
62062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62063       };
62064     }
62065   }
62066
62067 }
62068
62069
62070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62072
62073   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62074   {
62075     try {
62076       (arg1)->OnInitialize();
62077     } catch (std::out_of_range& e) {
62078       {
62079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62080       };
62081     } catch (std::exception& e) {
62082       {
62083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62084       };
62085     } catch (Dali::DaliException e) {
62086       {
62087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62088       };
62089     } catch (...) {
62090       {
62091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62092       };
62093     }
62094   }
62095
62096 }
62097
62098
62099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62101
62102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62103   {
62104     try {
62105       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62106     } catch (std::out_of_range& e) {
62107       {
62108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62109       };
62110     } catch (std::exception& e) {
62111       {
62112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62113       };
62114     } catch (Dali::DaliException e) {
62115       {
62116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62117       };
62118     } catch (...) {
62119       {
62120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62121       };
62122     }
62123   }
62124
62125 }
62126
62127
62128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
62129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62130   Dali::Actor *arg2 = 0 ;
62131
62132   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62133   arg2 = (Dali::Actor *)jarg2;
62134   if (!arg2) {
62135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62136     return ;
62137   }
62138   {
62139     try {
62140       (arg1)->OnControlChildAdd(*arg2);
62141     } catch (std::out_of_range& e) {
62142       {
62143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62144       };
62145     } catch (std::exception& e) {
62146       {
62147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62148       };
62149     } catch (Dali::DaliException e) {
62150       {
62151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62152       };
62153     } catch (...) {
62154       {
62155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62156       };
62157     }
62158   }
62159
62160 }
62161
62162
62163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62164   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62165   Dali::Actor *arg2 = 0 ;
62166
62167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62168   arg2 = (Dali::Actor *)jarg2;
62169   if (!arg2) {
62170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62171     return ;
62172   }
62173   {
62174     try {
62175       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
62176     } catch (std::out_of_range& e) {
62177       {
62178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62179       };
62180     } catch (std::exception& e) {
62181       {
62182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62183       };
62184     } catch (Dali::DaliException e) {
62185       {
62186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62187       };
62188     } catch (...) {
62189       {
62190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62191       };
62192     }
62193   }
62194
62195 }
62196
62197
62198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
62199   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62200   Dali::Actor *arg2 = 0 ;
62201
62202   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62203   arg2 = (Dali::Actor *)jarg2;
62204   if (!arg2) {
62205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62206     return ;
62207   }
62208   {
62209     try {
62210       (arg1)->OnControlChildRemove(*arg2);
62211     } catch (std::out_of_range& e) {
62212       {
62213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62214       };
62215     } catch (std::exception& e) {
62216       {
62217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62218       };
62219     } catch (Dali::DaliException e) {
62220       {
62221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62222       };
62223     } catch (...) {
62224       {
62225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62226       };
62227     }
62228   }
62229
62230 }
62231
62232
62233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62234   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62235   Dali::Actor *arg2 = 0 ;
62236
62237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62238   arg2 = (Dali::Actor *)jarg2;
62239   if (!arg2) {
62240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62241     return ;
62242   }
62243   {
62244     try {
62245       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
62246     } catch (std::out_of_range& e) {
62247       {
62248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62249       };
62250     } catch (std::exception& e) {
62251       {
62252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62253       };
62254     } catch (Dali::DaliException e) {
62255       {
62256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62257       };
62258     } catch (...) {
62259       {
62260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62261       };
62262     }
62263   }
62264
62265 }
62266
62267
62268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
62269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62270   Dali::Toolkit::StyleManager arg2 ;
62271   Dali::StyleChange::Type arg3 ;
62272   Dali::Toolkit::StyleManager *argp2 ;
62273
62274   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62275   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62276   if (!argp2) {
62277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62278     return ;
62279   }
62280   arg2 = *argp2;
62281   arg3 = (Dali::StyleChange::Type)jarg3;
62282   {
62283     try {
62284       (arg1)->OnStyleChange(arg2,arg3);
62285     } catch (std::out_of_range& e) {
62286       {
62287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62288       };
62289     } catch (std::exception& e) {
62290       {
62291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62292       };
62293     } catch (Dali::DaliException e) {
62294       {
62295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62296       };
62297     } catch (...) {
62298       {
62299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62300       };
62301     }
62302   }
62303
62304 }
62305
62306
62307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62309   Dali::Toolkit::StyleManager arg2 ;
62310   Dali::StyleChange::Type arg3 ;
62311   Dali::Toolkit::StyleManager *argp2 ;
62312
62313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62314   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62315   if (!argp2) {
62316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62317     return ;
62318   }
62319   arg2 = *argp2;
62320   arg3 = (Dali::StyleChange::Type)jarg3;
62321   {
62322     try {
62323       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62324     } catch (std::out_of_range& e) {
62325       {
62326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62327       };
62328     } catch (std::exception& e) {
62329       {
62330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62331       };
62332     } catch (Dali::DaliException e) {
62333       {
62334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62335       };
62336     } catch (...) {
62337       {
62338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62339       };
62340     }
62341   }
62342
62343 }
62344
62345
62346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62347   unsigned int jresult ;
62348   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62349   bool result;
62350
62351   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62352   {
62353     try {
62354       result = (bool)(arg1)->OnAccessibilityActivated();
62355     } catch (std::out_of_range& e) {
62356       {
62357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62358       };
62359     } catch (std::exception& e) {
62360       {
62361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62362       };
62363     } catch (Dali::DaliException e) {
62364       {
62365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62366       };
62367     } catch (...) {
62368       {
62369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62370       };
62371     }
62372   }
62373
62374   jresult = result;
62375   return jresult;
62376 }
62377
62378
62379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62380   unsigned int jresult ;
62381   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62382   bool result;
62383
62384   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62385   {
62386     try {
62387       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62388     } catch (std::out_of_range& e) {
62389       {
62390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62391       };
62392     } catch (std::exception& e) {
62393       {
62394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62395       };
62396     } catch (Dali::DaliException e) {
62397       {
62398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62399       };
62400     } catch (...) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62403       };
62404     }
62405   }
62406
62407   jresult = result;
62408   return jresult;
62409 }
62410
62411
62412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62413   unsigned int jresult ;
62414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62415   Dali::PanGesture arg2 ;
62416   Dali::PanGesture *argp2 ;
62417   bool result;
62418
62419   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62420   argp2 = (Dali::PanGesture *)jarg2;
62421   if (!argp2) {
62422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62423     return 0;
62424   }
62425   arg2 = *argp2;
62426   {
62427     try {
62428       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62429     } catch (std::out_of_range& e) {
62430       {
62431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62432       };
62433     } catch (std::exception& e) {
62434       {
62435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62436       };
62437     } catch (Dali::DaliException e) {
62438       {
62439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62440       };
62441     } catch (...) {
62442       {
62443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62444       };
62445     }
62446   }
62447
62448   jresult = result;
62449   return jresult;
62450 }
62451
62452
62453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62454   unsigned int jresult ;
62455   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62456   Dali::PanGesture arg2 ;
62457   Dali::PanGesture *argp2 ;
62458   bool result;
62459
62460   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62461   argp2 = (Dali::PanGesture *)jarg2;
62462   if (!argp2) {
62463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62464     return 0;
62465   }
62466   arg2 = *argp2;
62467   {
62468     try {
62469       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62470     } catch (std::out_of_range& e) {
62471       {
62472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62473       };
62474     } catch (std::exception& e) {
62475       {
62476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62477       };
62478     } catch (Dali::DaliException e) {
62479       {
62480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62481       };
62482     } catch (...) {
62483       {
62484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62485       };
62486     }
62487   }
62488
62489   jresult = result;
62490   return jresult;
62491 }
62492
62493
62494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62495   unsigned int jresult ;
62496   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62497   Dali::TouchEvent *arg2 = 0 ;
62498   bool result;
62499
62500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62501   arg2 = (Dali::TouchEvent *)jarg2;
62502   if (!arg2) {
62503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62504     return 0;
62505   }
62506   {
62507     try {
62508       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62509     } catch (std::out_of_range& e) {
62510       {
62511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62512       };
62513     } catch (std::exception& e) {
62514       {
62515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62516       };
62517     } catch (Dali::DaliException e) {
62518       {
62519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62520       };
62521     } catch (...) {
62522       {
62523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62524       };
62525     }
62526   }
62527
62528   jresult = result;
62529   return jresult;
62530 }
62531
62532
62533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62534   unsigned int jresult ;
62535   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62536   Dali::TouchEvent *arg2 = 0 ;
62537   bool result;
62538
62539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62540   arg2 = (Dali::TouchEvent *)jarg2;
62541   if (!arg2) {
62542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62543     return 0;
62544   }
62545   {
62546     try {
62547       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62548     } catch (std::out_of_range& e) {
62549       {
62550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62551       };
62552     } catch (std::exception& e) {
62553       {
62554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62555       };
62556     } catch (Dali::DaliException e) {
62557       {
62558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62559       };
62560     } catch (...) {
62561       {
62562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62563       };
62564     }
62565   }
62566
62567   jresult = result;
62568   return jresult;
62569 }
62570
62571
62572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62573   unsigned int jresult ;
62574   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62575   bool arg2 ;
62576   bool result;
62577
62578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62579   arg2 = jarg2 ? true : false;
62580   {
62581     try {
62582       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62583     } catch (std::out_of_range& e) {
62584       {
62585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62586       };
62587     } catch (std::exception& e) {
62588       {
62589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62590       };
62591     } catch (Dali::DaliException e) {
62592       {
62593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62594       };
62595     } catch (...) {
62596       {
62597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62598       };
62599     }
62600   }
62601
62602   jresult = result;
62603   return jresult;
62604 }
62605
62606
62607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62608   unsigned int jresult ;
62609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62610   bool arg2 ;
62611   bool result;
62612
62613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62614   arg2 = jarg2 ? true : false;
62615   {
62616     try {
62617       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62618     } catch (std::out_of_range& e) {
62619       {
62620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62621       };
62622     } catch (std::exception& e) {
62623       {
62624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62625       };
62626     } catch (Dali::DaliException e) {
62627       {
62628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62629       };
62630     } catch (...) {
62631       {
62632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62633       };
62634     }
62635   }
62636
62637   jresult = result;
62638   return jresult;
62639 }
62640
62641
62642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62643   unsigned int jresult ;
62644   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62645   bool result;
62646
62647   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62648   {
62649     try {
62650       result = (bool)(arg1)->OnAccessibilityZoom();
62651     } catch (std::out_of_range& e) {
62652       {
62653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62654       };
62655     } catch (std::exception& e) {
62656       {
62657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62658       };
62659     } catch (Dali::DaliException e) {
62660       {
62661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62662       };
62663     } catch (...) {
62664       {
62665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62666       };
62667     }
62668   }
62669
62670   jresult = result;
62671   return jresult;
62672 }
62673
62674
62675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62676   unsigned int jresult ;
62677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62678   bool result;
62679
62680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62681   {
62682     try {
62683       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62684     } catch (std::out_of_range& e) {
62685       {
62686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62687       };
62688     } catch (std::exception& e) {
62689       {
62690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62691       };
62692     } catch (Dali::DaliException e) {
62693       {
62694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62695       };
62696     } catch (...) {
62697       {
62698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62699       };
62700     }
62701   }
62702
62703   jresult = result;
62704   return jresult;
62705 }
62706
62707
62708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62710
62711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62712   {
62713     try {
62714       (arg1)->OnKeyInputFocusGained();
62715     } catch (std::out_of_range& e) {
62716       {
62717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62718       };
62719     } catch (std::exception& e) {
62720       {
62721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62722       };
62723     } catch (Dali::DaliException e) {
62724       {
62725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62726       };
62727     } catch (...) {
62728       {
62729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62730       };
62731     }
62732   }
62733
62734 }
62735
62736
62737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62739
62740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62741   {
62742     try {
62743       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62744     } catch (std::out_of_range& e) {
62745       {
62746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62747       };
62748     } catch (std::exception& e) {
62749       {
62750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62751       };
62752     } catch (Dali::DaliException e) {
62753       {
62754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62755       };
62756     } catch (...) {
62757       {
62758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62759       };
62760     }
62761   }
62762
62763 }
62764
62765
62766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62768
62769   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62770   {
62771     try {
62772       (arg1)->OnKeyInputFocusLost();
62773     } catch (std::out_of_range& e) {
62774       {
62775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62776       };
62777     } catch (std::exception& e) {
62778       {
62779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62780       };
62781     } catch (Dali::DaliException e) {
62782       {
62783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62784       };
62785     } catch (...) {
62786       {
62787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62788       };
62789     }
62790   }
62791
62792 }
62793
62794
62795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62796   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62797
62798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62799   {
62800     try {
62801       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62802     } catch (std::out_of_range& e) {
62803       {
62804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62805       };
62806     } catch (std::exception& e) {
62807       {
62808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62809       };
62810     } catch (Dali::DaliException e) {
62811       {
62812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62813       };
62814     } catch (...) {
62815       {
62816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62817       };
62818     }
62819   }
62820
62821 }
62822
62823
62824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62825   void * jresult ;
62826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62827   Dali::Actor arg2 ;
62828   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62829   bool arg4 ;
62830   Dali::Actor *argp2 ;
62831   Dali::Actor result;
62832
62833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62834   argp2 = (Dali::Actor *)jarg2;
62835   if (!argp2) {
62836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62837     return 0;
62838   }
62839   arg2 = *argp2;
62840   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62841   arg4 = jarg4 ? true : false;
62842   {
62843     try {
62844       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62845     } catch (std::out_of_range& e) {
62846       {
62847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62848       };
62849     } catch (std::exception& e) {
62850       {
62851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62852       };
62853     } catch (Dali::DaliException e) {
62854       {
62855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62856       };
62857     } catch (...) {
62858       {
62859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62860       };
62861     }
62862   }
62863
62864   jresult = new Dali::Actor((const Dali::Actor &)result);
62865   return jresult;
62866 }
62867
62868
62869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62870   void * jresult ;
62871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62872   Dali::Actor arg2 ;
62873   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62874   bool arg4 ;
62875   Dali::Actor *argp2 ;
62876   Dali::Actor result;
62877
62878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62879   argp2 = (Dali::Actor *)jarg2;
62880   if (!argp2) {
62881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62882     return 0;
62883   }
62884   arg2 = *argp2;
62885   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62886   arg4 = jarg4 ? true : false;
62887   {
62888     try {
62889       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62890     } catch (std::out_of_range& e) {
62891       {
62892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62893       };
62894     } catch (std::exception& e) {
62895       {
62896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62897       };
62898     } catch (Dali::DaliException e) {
62899       {
62900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62901       };
62902     } catch (...) {
62903       {
62904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62905       };
62906     }
62907   }
62908
62909   jresult = new Dali::Actor((const Dali::Actor &)result);
62910   return jresult;
62911 }
62912
62913
62914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62916   Dali::Actor arg2 ;
62917   Dali::Actor *argp2 ;
62918
62919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62920   argp2 = (Dali::Actor *)jarg2;
62921   if (!argp2) {
62922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62923     return ;
62924   }
62925   arg2 = *argp2;
62926   {
62927     try {
62928       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62929     } catch (std::out_of_range& e) {
62930       {
62931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62932       };
62933     } catch (std::exception& e) {
62934       {
62935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62936       };
62937     } catch (Dali::DaliException e) {
62938       {
62939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62940       };
62941     } catch (...) {
62942       {
62943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62944       };
62945     }
62946   }
62947
62948 }
62949
62950
62951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62952   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62953   Dali::Actor arg2 ;
62954   Dali::Actor *argp2 ;
62955
62956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62957   argp2 = (Dali::Actor *)jarg2;
62958   if (!argp2) {
62959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62960     return ;
62961   }
62962   arg2 = *argp2;
62963   {
62964     try {
62965       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62966     } catch (std::out_of_range& e) {
62967       {
62968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62969       };
62970     } catch (std::exception& e) {
62971       {
62972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62973       };
62974     } catch (Dali::DaliException e) {
62975       {
62976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62977       };
62978     } catch (...) {
62979       {
62980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62981       };
62982     }
62983   }
62984
62985 }
62986
62987
62988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62989   unsigned int jresult ;
62990   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62991   bool result;
62992
62993   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62994   {
62995     try {
62996       result = (bool)(arg1)->OnKeyboardEnter();
62997     } catch (std::out_of_range& e) {
62998       {
62999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63000       };
63001     } catch (std::exception& e) {
63002       {
63003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63004       };
63005     } catch (Dali::DaliException e) {
63006       {
63007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63008       };
63009     } catch (...) {
63010       {
63011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63012       };
63013     }
63014   }
63015
63016   jresult = result;
63017   return jresult;
63018 }
63019
63020
63021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
63022   unsigned int jresult ;
63023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63024   bool result;
63025
63026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63027   {
63028     try {
63029       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
63030     } catch (std::out_of_range& e) {
63031       {
63032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63033       };
63034     } catch (std::exception& e) {
63035       {
63036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63037       };
63038     } catch (Dali::DaliException e) {
63039       {
63040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63041       };
63042     } catch (...) {
63043       {
63044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63045       };
63046     }
63047   }
63048
63049   jresult = result;
63050   return jresult;
63051 }
63052
63053
63054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
63055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63056   Dali::PinchGesture *arg2 = 0 ;
63057
63058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63059   arg2 = (Dali::PinchGesture *)jarg2;
63060   if (!arg2) {
63061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
63062     return ;
63063   }
63064   {
63065     try {
63066       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
63067     } catch (std::out_of_range& e) {
63068       {
63069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63070       };
63071     } catch (std::exception& e) {
63072       {
63073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63074       };
63075     } catch (Dali::DaliException e) {
63076       {
63077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63078       };
63079     } catch (...) {
63080       {
63081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63082       };
63083     }
63084   }
63085
63086 }
63087
63088
63089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63090   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63091   Dali::PinchGesture *arg2 = 0 ;
63092
63093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63094   arg2 = (Dali::PinchGesture *)jarg2;
63095   if (!arg2) {
63096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
63097     return ;
63098   }
63099   {
63100     try {
63101       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
63102     } catch (std::out_of_range& e) {
63103       {
63104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63105       };
63106     } catch (std::exception& e) {
63107       {
63108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63109       };
63110     } catch (Dali::DaliException e) {
63111       {
63112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63113       };
63114     } catch (...) {
63115       {
63116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63117       };
63118     }
63119   }
63120
63121 }
63122
63123
63124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
63125   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63126   Dali::PanGesture *arg2 = 0 ;
63127
63128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63129   arg2 = (Dali::PanGesture *)jarg2;
63130   if (!arg2) {
63131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63132     return ;
63133   }
63134   {
63135     try {
63136       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
63137     } catch (std::out_of_range& e) {
63138       {
63139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63140       };
63141     } catch (std::exception& e) {
63142       {
63143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63144       };
63145     } catch (Dali::DaliException e) {
63146       {
63147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63148       };
63149     } catch (...) {
63150       {
63151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63152       };
63153     }
63154   }
63155
63156 }
63157
63158
63159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63160   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63161   Dali::PanGesture *arg2 = 0 ;
63162
63163   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63164   arg2 = (Dali::PanGesture *)jarg2;
63165   if (!arg2) {
63166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63167     return ;
63168   }
63169   {
63170     try {
63171       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
63172     } catch (std::out_of_range& e) {
63173       {
63174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63175       };
63176     } catch (std::exception& e) {
63177       {
63178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63179       };
63180     } catch (Dali::DaliException e) {
63181       {
63182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63183       };
63184     } catch (...) {
63185       {
63186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63187       };
63188     }
63189   }
63190
63191 }
63192
63193
63194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
63195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63196   Dali::TapGesture *arg2 = 0 ;
63197
63198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63199   arg2 = (Dali::TapGesture *)jarg2;
63200   if (!arg2) {
63201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63202     return ;
63203   }
63204   {
63205     try {
63206       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
63207     } catch (std::out_of_range& e) {
63208       {
63209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63210       };
63211     } catch (std::exception& e) {
63212       {
63213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63214       };
63215     } catch (Dali::DaliException e) {
63216       {
63217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63218       };
63219     } catch (...) {
63220       {
63221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63222       };
63223     }
63224   }
63225
63226 }
63227
63228
63229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63230   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63231   Dali::TapGesture *arg2 = 0 ;
63232
63233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63234   arg2 = (Dali::TapGesture *)jarg2;
63235   if (!arg2) {
63236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63237     return ;
63238   }
63239   {
63240     try {
63241       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
63242     } catch (std::out_of_range& e) {
63243       {
63244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63245       };
63246     } catch (std::exception& e) {
63247       {
63248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63249       };
63250     } catch (Dali::DaliException e) {
63251       {
63252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63253       };
63254     } catch (...) {
63255       {
63256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63257       };
63258     }
63259   }
63260
63261 }
63262
63263
63264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
63265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63266   Dali::LongPressGesture *arg2 = 0 ;
63267
63268   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63269   arg2 = (Dali::LongPressGesture *)jarg2;
63270   if (!arg2) {
63271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63272     return ;
63273   }
63274   {
63275     try {
63276       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
63277     } catch (std::out_of_range& e) {
63278       {
63279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63280       };
63281     } catch (std::exception& e) {
63282       {
63283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63284       };
63285     } catch (Dali::DaliException e) {
63286       {
63287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63288       };
63289     } catch (...) {
63290       {
63291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63292       };
63293     }
63294   }
63295
63296 }
63297
63298
63299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63300   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63301   Dali::LongPressGesture *arg2 = 0 ;
63302
63303   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63304   arg2 = (Dali::LongPressGesture *)jarg2;
63305   if (!arg2) {
63306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63307     return ;
63308   }
63309   {
63310     try {
63311       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
63312     } catch (std::out_of_range& e) {
63313       {
63314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63315       };
63316     } catch (std::exception& e) {
63317       {
63318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63319       };
63320     } catch (Dali::DaliException e) {
63321       {
63322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63323       };
63324     } catch (...) {
63325       {
63326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63327       };
63328     }
63329   }
63330
63331 }
63332
63333
63334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
63335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63336   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63337   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63338
63339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63340   arg2 = (Dali::SlotObserver *)jarg2;
63341   arg3 = (Dali::CallbackBase *)jarg3;
63342   {
63343     try {
63344       (arg1)->SignalConnected(arg2,arg3);
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 void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63369   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63370   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63371
63372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63373   arg2 = (Dali::SlotObserver *)jarg2;
63374   arg3 = (Dali::CallbackBase *)jarg3;
63375   {
63376     try {
63377       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63378     } catch (std::out_of_range& e) {
63379       {
63380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63381       };
63382     } catch (std::exception& e) {
63383       {
63384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63385       };
63386     } catch (Dali::DaliException e) {
63387       {
63388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63389       };
63390     } catch (...) {
63391       {
63392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63393       };
63394     }
63395   }
63396
63397 }
63398
63399
63400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63402   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63403   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63404
63405   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63406   arg2 = (Dali::SlotObserver *)jarg2;
63407   arg3 = (Dali::CallbackBase *)jarg3;
63408   {
63409     try {
63410       (arg1)->SignalDisconnected(arg2,arg3);
63411     } catch (std::out_of_range& e) {
63412       {
63413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63414       };
63415     } catch (std::exception& e) {
63416       {
63417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63418       };
63419     } catch (Dali::DaliException e) {
63420       {
63421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63422       };
63423     } catch (...) {
63424       {
63425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63426       };
63427     }
63428   }
63429
63430 }
63431
63432
63433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63435   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63436   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63437
63438   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63439   arg2 = (Dali::SlotObserver *)jarg2;
63440   arg3 = (Dali::CallbackBase *)jarg3;
63441   {
63442     try {
63443       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63444     } catch (std::out_of_range& e) {
63445       {
63446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63447       };
63448     } catch (std::exception& e) {
63449       {
63450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63451       };
63452     } catch (Dali::DaliException e) {
63453       {
63454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63455       };
63456     } catch (...) {
63457       {
63458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63459       };
63460     }
63461   }
63462
63463 }
63464
63465
63466 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_Callback7_t callback7, 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_Callback22_t callback22, SwigDirector_ViewImpl::SWIG_Callback23_t callback23, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback27_t callback27, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
63467   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63468   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63469   if (director) {
63470     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24, callback25, callback26, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
63471   }
63472 }
63473
63474
63475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63476   void * jresult ;
63477   Dali::Toolkit::Control *arg1 = 0 ;
63478   Dali::Toolkit::Internal::Control *result = 0 ;
63479
63480   arg1 = (Dali::Toolkit::Control *)jarg1;
63481   if (!arg1) {
63482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63483     return 0;
63484   }
63485   {
63486     try {
63487       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63488     } catch (std::out_of_range& e) {
63489       {
63490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63491       };
63492     } catch (std::exception& e) {
63493       {
63494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63495       };
63496     } catch (Dali::DaliException e) {
63497       {
63498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63499       };
63500     } catch (...) {
63501       {
63502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63503       };
63504     }
63505   }
63506
63507   jresult = (void *)result;
63508   return jresult;
63509 }
63510
63511
63512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63513   int jresult ;
63514   int result;
63515
63516   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63517   jresult = (int)result;
63518   return jresult;
63519 }
63520
63521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63522   int jresult ;
63523   int result;
63524
63525   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63526   jresult = (int)result;
63527   return jresult;
63528 }
63529
63530
63531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63532   int jresult ;
63533   int result;
63534
63535   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63536   jresult = (int)result;
63537   return jresult;
63538 }
63539
63540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
63541   int jresult ;
63542   int result;
63543
63544   result = (int)Dali::Toolkit::Control::Property::MARGIN;
63545   jresult = (int)result;
63546   return jresult;
63547 }
63548
63549
63550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
63551   int jresult ;
63552   int result;
63553
63554   result = (int)Dali::Toolkit::Control::Property::PADDING;
63555   jresult = (int)result;
63556   return jresult;
63557 }
63558
63559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
63560   int jresult ;
63561   int result;
63562
63563   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
63564   jresult = (int)result;
63565   return jresult;
63566 }
63567
63568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63569   void * jresult ;
63570   Dali::Toolkit::Control::Property *result = 0 ;
63571
63572   {
63573     try {
63574       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63575     } catch (std::out_of_range& e) {
63576       {
63577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63578       };
63579     } catch (std::exception& e) {
63580       {
63581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63582       };
63583     } catch (Dali::DaliException e) {
63584       {
63585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63586       };
63587     } catch (...) {
63588       {
63589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63590       };
63591     }
63592   }
63593
63594   jresult = (void *)result;
63595   return jresult;
63596 }
63597
63598
63599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63600   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63601
63602   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63603   {
63604     try {
63605       delete arg1;
63606     } catch (std::out_of_range& e) {
63607       {
63608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63609       };
63610     } catch (std::exception& e) {
63611       {
63612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63613       };
63614     } catch (Dali::DaliException e) {
63615       {
63616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63617       };
63618     } catch (...) {
63619       {
63620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63621       };
63622     }
63623   }
63624
63625 }
63626
63627
63628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63629   void * jresult ;
63630   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63631
63632   {
63633     try {
63634       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63635     } catch (std::out_of_range& e) {
63636       {
63637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63638       };
63639     } catch (std::exception& e) {
63640       {
63641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63642       };
63643     } catch (Dali::DaliException e) {
63644       {
63645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63646       };
63647     } catch (...) {
63648       {
63649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63650       };
63651     }
63652   }
63653
63654   jresult = (void *)result;
63655   return jresult;
63656 }
63657
63658
63659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63660   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63661
63662   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63663   {
63664     try {
63665       delete arg1;
63666     } catch (std::out_of_range& e) {
63667       {
63668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63669       };
63670     } catch (std::exception& e) {
63671       {
63672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63673       };
63674     } catch (Dali::DaliException e) {
63675       {
63676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63677       };
63678     } catch (...) {
63679       {
63680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63681       };
63682     }
63683   }
63684
63685 }
63686
63687
63688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63689   void * jresult ;
63690   Dali::Toolkit::Control result;
63691
63692   {
63693     try {
63694       result = Dali::Toolkit::Control::New();
63695     } catch (std::out_of_range& e) {
63696       {
63697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63698       };
63699     } catch (std::exception& e) {
63700       {
63701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63702       };
63703     } catch (Dali::DaliException e) {
63704       {
63705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63706       };
63707     } catch (...) {
63708       {
63709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63710       };
63711     }
63712   }
63713
63714   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63715   return jresult;
63716 }
63717
63718
63719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63720   void * jresult ;
63721   Dali::Toolkit::Control *result = 0 ;
63722
63723   {
63724     try {
63725       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63726     } catch (std::out_of_range& e) {
63727       {
63728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63729       };
63730     } catch (std::exception& e) {
63731       {
63732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63733       };
63734     } catch (Dali::DaliException e) {
63735       {
63736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63737       };
63738     } catch (...) {
63739       {
63740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63741       };
63742     }
63743   }
63744
63745   jresult = (void *)result;
63746   return jresult;
63747 }
63748
63749
63750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63751   void * jresult ;
63752   Dali::Toolkit::Control *arg1 = 0 ;
63753   Dali::Toolkit::Control *result = 0 ;
63754
63755   arg1 = (Dali::Toolkit::Control *)jarg1;
63756   if (!arg1) {
63757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63758     return 0;
63759   }
63760   {
63761     try {
63762       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63763     } catch (std::out_of_range& e) {
63764       {
63765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63766       };
63767     } catch (std::exception& e) {
63768       {
63769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63770       };
63771     } catch (Dali::DaliException e) {
63772       {
63773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63774       };
63775     } catch (...) {
63776       {
63777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63778       };
63779     }
63780   }
63781
63782   jresult = (void *)result;
63783   return jresult;
63784 }
63785
63786
63787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63788   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63789
63790   arg1 = (Dali::Toolkit::Control *)jarg1;
63791   {
63792     try {
63793       delete arg1;
63794     } catch (std::out_of_range& e) {
63795       {
63796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63797       };
63798     } catch (std::exception& e) {
63799       {
63800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63801       };
63802     } catch (Dali::DaliException e) {
63803       {
63804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63805       };
63806     } catch (...) {
63807       {
63808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63809       };
63810     }
63811   }
63812
63813 }
63814
63815
63816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63817   void * jresult ;
63818   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63819   Dali::Toolkit::Control *arg2 = 0 ;
63820   Dali::Toolkit::Control *result = 0 ;
63821
63822   arg1 = (Dali::Toolkit::Control *)jarg1;
63823   arg2 = (Dali::Toolkit::Control *)jarg2;
63824   if (!arg2) {
63825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63826     return 0;
63827   }
63828   {
63829     try {
63830       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63831     } catch (std::out_of_range& e) {
63832       {
63833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63834       };
63835     } catch (std::exception& e) {
63836       {
63837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63838       };
63839     } catch (Dali::DaliException e) {
63840       {
63841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63842       };
63843     } catch (...) {
63844       {
63845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63846       };
63847     }
63848   }
63849
63850   jresult = (void *)result;
63851   return jresult;
63852 }
63853
63854
63855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63856   void * jresult ;
63857   Dali::BaseHandle arg1 ;
63858   Dali::BaseHandle *argp1 ;
63859   Dali::Toolkit::Control result;
63860
63861   argp1 = (Dali::BaseHandle *)jarg1;
63862   if (!argp1) {
63863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63864     return 0;
63865   }
63866   arg1 = *argp1;
63867   {
63868     try {
63869       result = Dali::Toolkit::Control::DownCast(arg1);
63870     } catch (std::out_of_range& e) {
63871       {
63872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63873       };
63874     } catch (std::exception& e) {
63875       {
63876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63877       };
63878     } catch (Dali::DaliException e) {
63879       {
63880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63881       };
63882     } catch (...) {
63883       {
63884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63885       };
63886     }
63887   }
63888
63889   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63890   return jresult;
63891 }
63892
63893
63894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63895   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63896
63897   arg1 = (Dali::Toolkit::Control *)jarg1;
63898   {
63899     try {
63900       (arg1)->SetKeyInputFocus();
63901     } catch (std::out_of_range& e) {
63902       {
63903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63904       };
63905     } catch (std::exception& e) {
63906       {
63907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63908       };
63909     } catch (Dali::DaliException e) {
63910       {
63911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63912       };
63913     } catch (...) {
63914       {
63915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63916       };
63917     }
63918   }
63919
63920 }
63921
63922
63923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63924   unsigned int jresult ;
63925   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63926   bool result;
63927
63928   arg1 = (Dali::Toolkit::Control *)jarg1;
63929   {
63930     try {
63931       result = (bool)(arg1)->HasKeyInputFocus();
63932     } catch (std::out_of_range& e) {
63933       {
63934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63935       };
63936     } catch (std::exception& e) {
63937       {
63938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63939       };
63940     } catch (Dali::DaliException e) {
63941       {
63942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63943       };
63944     } catch (...) {
63945       {
63946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63947       };
63948     }
63949   }
63950
63951   jresult = result;
63952   return jresult;
63953 }
63954
63955
63956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63957   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63958
63959   arg1 = (Dali::Toolkit::Control *)jarg1;
63960   {
63961     try {
63962       (arg1)->ClearKeyInputFocus();
63963     } catch (std::out_of_range& e) {
63964       {
63965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63966       };
63967     } catch (std::exception& e) {
63968       {
63969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63970       };
63971     } catch (Dali::DaliException e) {
63972       {
63973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63974       };
63975     } catch (...) {
63976       {
63977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63978       };
63979     }
63980   }
63981
63982 }
63983
63984
63985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63986   void * jresult ;
63987   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63988   Dali::PinchGestureDetector result;
63989
63990   arg1 = (Dali::Toolkit::Control *)jarg1;
63991   {
63992     try {
63993       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63994     } catch (std::out_of_range& e) {
63995       {
63996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63997       };
63998     } catch (std::exception& e) {
63999       {
64000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64001       };
64002     } catch (Dali::DaliException e) {
64003       {
64004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64005       };
64006     } catch (...) {
64007       {
64008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64009       };
64010     }
64011   }
64012
64013   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
64014   return jresult;
64015 }
64016
64017
64018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
64019   void * jresult ;
64020   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64021   Dali::PanGestureDetector result;
64022
64023   arg1 = (Dali::Toolkit::Control *)jarg1;
64024   {
64025     try {
64026       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
64027     } catch (std::out_of_range& e) {
64028       {
64029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64030       };
64031     } catch (std::exception& e) {
64032       {
64033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64034       };
64035     } catch (Dali::DaliException e) {
64036       {
64037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64038       };
64039     } catch (...) {
64040       {
64041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64042       };
64043     }
64044   }
64045
64046   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
64047   return jresult;
64048 }
64049
64050
64051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
64052   void * jresult ;
64053   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64054   Dali::TapGestureDetector result;
64055
64056   arg1 = (Dali::Toolkit::Control *)jarg1;
64057   {
64058     try {
64059       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
64060     } catch (std::out_of_range& e) {
64061       {
64062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64063       };
64064     } catch (std::exception& e) {
64065       {
64066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64067       };
64068     } catch (Dali::DaliException e) {
64069       {
64070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64071       };
64072     } catch (...) {
64073       {
64074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64075       };
64076     }
64077   }
64078
64079   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
64080   return jresult;
64081 }
64082
64083
64084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
64085   void * jresult ;
64086   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64087   Dali::LongPressGestureDetector result;
64088
64089   arg1 = (Dali::Toolkit::Control *)jarg1;
64090   {
64091     try {
64092       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
64093     } catch (std::out_of_range& e) {
64094       {
64095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64096       };
64097     } catch (std::exception& e) {
64098       {
64099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64100       };
64101     } catch (Dali::DaliException e) {
64102       {
64103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64104       };
64105     } catch (...) {
64106       {
64107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64108       };
64109     }
64110   }
64111
64112   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
64113   return jresult;
64114 }
64115
64116
64117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
64118   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64119   std::string *arg2 = 0 ;
64120
64121   arg1 = (Dali::Toolkit::Control *)jarg1;
64122   if (!jarg2) {
64123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64124     return ;
64125   }
64126   std::string arg2_str(jarg2);
64127   arg2 = &arg2_str;
64128   {
64129     try {
64130       (arg1)->SetStyleName((std::string const &)*arg2);
64131     } catch (std::out_of_range& e) {
64132       {
64133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64134       };
64135     } catch (std::exception& e) {
64136       {
64137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64138       };
64139     } catch (Dali::DaliException e) {
64140       {
64141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64142       };
64143     } catch (...) {
64144       {
64145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64146       };
64147     }
64148   }
64149
64150
64151   //argout typemap for const std::string&
64152
64153 }
64154
64155
64156 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
64157   char * jresult ;
64158   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64159   std::string *result = 0 ;
64160
64161   arg1 = (Dali::Toolkit::Control *)jarg1;
64162   {
64163     try {
64164       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
64165     } catch (std::out_of_range& e) {
64166       {
64167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64168       };
64169     } catch (std::exception& e) {
64170       {
64171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64172       };
64173     } catch (Dali::DaliException e) {
64174       {
64175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64176       };
64177     } catch (...) {
64178       {
64179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64180       };
64181     }
64182   }
64183
64184   jresult = SWIG_csharp_string_callback(result->c_str());
64185   return jresult;
64186 }
64187
64188
64189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
64190   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64191   Dali::Vector4 *arg2 = 0 ;
64192
64193   arg1 = (Dali::Toolkit::Control *)jarg1;
64194   arg2 = (Dali::Vector4 *)jarg2;
64195   if (!arg2) {
64196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
64197     return ;
64198   }
64199   {
64200     try {
64201       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
64202     } catch (std::out_of_range& e) {
64203       {
64204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64205       };
64206     } catch (std::exception& e) {
64207       {
64208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64209       };
64210     } catch (Dali::DaliException e) {
64211       {
64212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64213       };
64214     } catch (...) {
64215       {
64216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64217       };
64218     }
64219   }
64220
64221 }
64222
64223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
64224   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64225
64226   arg1 = (Dali::Toolkit::Control *)jarg1;
64227   {
64228     try {
64229       (arg1)->ClearBackground();
64230     } catch (std::out_of_range& e) {
64231       {
64232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64233       };
64234     } catch (std::exception& e) {
64235       {
64236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64237       };
64238     } catch (Dali::DaliException e) {
64239       {
64240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64241       };
64242     } catch (...) {
64243       {
64244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64245       };
64246     }
64247   }
64248
64249 }
64250
64251
64252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
64253   void * jresult ;
64254   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64255   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64256
64257   arg1 = (Dali::Toolkit::Control *)jarg1;
64258   {
64259     try {
64260       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64261     } catch (std::out_of_range& e) {
64262       {
64263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64264       };
64265     } catch (std::exception& e) {
64266       {
64267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64268       };
64269     } catch (Dali::DaliException e) {
64270       {
64271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64272       };
64273     } catch (...) {
64274       {
64275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64276       };
64277     }
64278   }
64279
64280   jresult = (void *)result;
64281   return jresult;
64282 }
64283
64284
64285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
64286   void * jresult ;
64287   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64288   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64289
64290   arg1 = (Dali::Toolkit::Control *)jarg1;
64291   {
64292     try {
64293       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64294     } catch (std::out_of_range& e) {
64295       {
64296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64297       };
64298     } catch (std::exception& e) {
64299       {
64300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64301       };
64302     } catch (Dali::DaliException e) {
64303       {
64304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64305       };
64306     } catch (...) {
64307       {
64308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64309       };
64310     }
64311   }
64312
64313   jresult = (void *)result;
64314   return jresult;
64315 }
64316
64317
64318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
64319   void * jresult ;
64320   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64321   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64322
64323   arg1 = (Dali::Toolkit::Control *)jarg1;
64324   {
64325     try {
64326       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64327     } catch (std::out_of_range& e) {
64328       {
64329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64330       };
64331     } catch (std::exception& e) {
64332       {
64333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64334       };
64335     } catch (Dali::DaliException e) {
64336       {
64337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64338       };
64339     } catch (...) {
64340       {
64341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64342       };
64343     }
64344   }
64345
64346   jresult = (void *)result;
64347   return jresult;
64348 }
64349
64350
64351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
64352   void * jresult ;
64353   Dali::Toolkit::Internal::Control *arg1 = 0 ;
64354   Dali::Toolkit::Control *result = 0 ;
64355
64356   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64357   if (!arg1) {
64358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
64359     return 0;
64360   }
64361   {
64362     try {
64363       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
64364     } catch (std::out_of_range& e) {
64365       {
64366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64367       };
64368     } catch (std::exception& e) {
64369       {
64370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64371       };
64372     } catch (Dali::DaliException e) {
64373       {
64374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64375       };
64376     } catch (...) {
64377       {
64378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64379       };
64380     }
64381   }
64382
64383   jresult = (void *)result;
64384   return jresult;
64385 }
64386
64387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
64388 {
64389   int jresult;
64390   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64391   arg1 = (Dali::Toolkit::Control *)jarg1;
64392
64393   if (!arg1) {
64394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64395     return 0;
64396   }
64397
64398   Dali::Property::Index arg2 = 0 ;
64399   arg2 = (Dali::Property::Index)jarg2;
64400
64401   Toolkit::Visual::ResourceStatus result;
64402   {
64403     try {
64404       result = arg1->GetVisualResourceStatus(arg2);
64405     } catch (std::out_of_range& e) {
64406       {
64407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64408       };
64409     } catch (std::exception& e) {
64410       {
64411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64412       };
64413     } catch (...) {
64414       {
64415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64416       };
64417     }
64418   }
64419   jresult = (int)(result);
64420   return jresult;
64421 }
64422
64423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
64424 {
64425   void * jresult;
64426   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64427   arg1 = (Dali::Toolkit::Control *)jarg1;
64428
64429   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
64430
64431   Dali::Toolkit::TransitionData *arg2 = 0 ;
64432   Dali::Animation result;
64433
64434   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
64435   if (!arg2) {
64436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
64437     return 0;
64438   }
64439   {
64440     try {
64441       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
64442     } catch (std::out_of_range& e) {
64443       {
64444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64445       };
64446     } catch (std::exception& e) {
64447       {
64448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64449       };
64450     } catch (Dali::DaliException e) {
64451       {
64452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64453       };
64454     } catch (...) {
64455       {
64456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64457       };
64458     }
64459   }
64460
64461   jresult = new Dali::Animation((const Dali::Animation &)result);
64462   return jresult;
64463 }
64464
64465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
64466 {
64467   Dali::Toolkit::Control arg1;
64468   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
64469
64470   if (!argp1) {
64471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64472   }
64473   arg1 = *argp1;
64474
64475   Dali::Property::Index arg2 = 0 ;
64476   arg2 = (Dali::Property::Index)jarg2;
64477
64478   Dali::Property::Index arg3 = 0 ;
64479   arg3 = (Dali::Property::Index)jarg3;
64480
64481   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
64482
64483   {
64484     try {
64485       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
64486     } catch (std::out_of_range& e) {
64487       {
64488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64489       };
64490     } catch (std::exception& e) {
64491       {
64492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64493       };
64494     } catch (...) {
64495       {
64496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64497       };
64498     }
64499   }
64500
64501
64502 }
64503
64504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64505   void * jresult ;
64506   Dali::Toolkit::Control *arg1 = 0 ;
64507   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
64508
64509   arg1 = (Dali::Toolkit::Control *)jarg1;
64510   if (!arg1) {
64511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64512     return 0;
64513   }
64514   {
64515     try {
64516       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
64517     } catch (std::out_of_range& e) {
64518       {
64519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64520       };
64521     } catch (std::exception& e) {
64522       {
64523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64524       };
64525     } catch (Dali::DaliException e) {
64526       {
64527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64528       };
64529     } catch (...) {
64530       {
64531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64532       };
64533     }
64534   }
64535
64536   jresult = (void *)result;
64537   return jresult;
64538 }
64539
64540
64541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64542   unsigned int jresult ;
64543   Dali::Toolkit::Control *arg1 = 0 ;
64544   bool result;
64545
64546   arg1 = (Dali::Toolkit::Control *)jarg1;
64547   if (!arg1) {
64548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64549     return 0;
64550   }
64551   {
64552     try {
64553       result = (bool)arg1->IsResourceReady();
64554     } catch (std::out_of_range& e) {
64555       {
64556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64557       };
64558     } catch (std::exception& e) {
64559       {
64560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64561       };
64562     } catch (Dali::DaliException e) {
64563       {
64564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64565       };
64566     } catch (...) {
64567       {
64568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64569       };
64570     }
64571   }
64572
64573   jresult = result;
64574   return jresult;
64575 }
64576
64577
64578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64579   void * jresult ;
64580   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64581
64582   {
64583     try {
64584       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64585     } catch (std::out_of_range& e) {
64586       {
64587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64588       };
64589     } catch (std::exception& e) {
64590       {
64591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64592       };
64593     } catch (Dali::DaliException e) {
64594       {
64595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64596       };
64597     } catch (...) {
64598       {
64599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64600       };
64601     }
64602   }
64603
64604   jresult = (void *)result;
64605   return jresult;
64606 }
64607
64608
64609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64610   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64611
64612   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64613   {
64614     try {
64615       delete arg1;
64616     } catch (std::out_of_range& e) {
64617       {
64618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64619       };
64620     } catch (std::exception& e) {
64621       {
64622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64623       };
64624     } catch (Dali::DaliException e) {
64625       {
64626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64627       };
64628     } catch (...) {
64629       {
64630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64631       };
64632     }
64633   }
64634
64635 }
64636
64637
64638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64639   void * jresult ;
64640   Dali::Toolkit::KeyInputFocusManager result;
64641
64642   {
64643     try {
64644       result = Dali::Toolkit::KeyInputFocusManager::Get();
64645     } catch (std::out_of_range& e) {
64646       {
64647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64648       };
64649     } catch (std::exception& e) {
64650       {
64651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64652       };
64653     } catch (Dali::DaliException e) {
64654       {
64655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64656       };
64657     } catch (...) {
64658       {
64659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64660       };
64661     }
64662   }
64663
64664   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64665   return jresult;
64666 }
64667
64668
64669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64670   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64671   Dali::Toolkit::Control arg2 ;
64672   Dali::Toolkit::Control *argp2 ;
64673
64674   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64675   argp2 = (Dali::Toolkit::Control *)jarg2;
64676   if (!argp2) {
64677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64678     return ;
64679   }
64680   arg2 = *argp2;
64681   {
64682     try {
64683       (arg1)->SetFocus(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 void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64707   void * jresult ;
64708   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64709   Dali::Toolkit::Control result;
64710
64711   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64712   {
64713     try {
64714       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
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 = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64735   return jresult;
64736 }
64737
64738
64739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64740   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64741   Dali::Toolkit::Control arg2 ;
64742   Dali::Toolkit::Control *argp2 ;
64743
64744   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64745   argp2 = (Dali::Toolkit::Control *)jarg2;
64746   if (!argp2) {
64747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64748     return ;
64749   }
64750   arg2 = *argp2;
64751   {
64752     try {
64753       (arg1)->RemoveFocus(arg2);
64754     } catch (std::out_of_range& e) {
64755       {
64756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64757       };
64758     } catch (std::exception& e) {
64759       {
64760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64761       };
64762     } catch (Dali::DaliException e) {
64763       {
64764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64765       };
64766     } catch (...) {
64767       {
64768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64769       };
64770     }
64771   }
64772
64773 }
64774
64775
64776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64777   void * jresult ;
64778   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64779   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64780
64781   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64782   {
64783     try {
64784       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64785     } catch (std::out_of_range& e) {
64786       {
64787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64788       };
64789     } catch (std::exception& e) {
64790       {
64791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64792       };
64793     } catch (Dali::DaliException e) {
64794       {
64795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64796       };
64797     } catch (...) {
64798       {
64799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64800       };
64801     }
64802   }
64803
64804   jresult = (void *)result;
64805   return jresult;
64806 }
64807
64808
64809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64810   void * jresult ;
64811   Dali::Toolkit::Alignment::Padding *result = 0 ;
64812
64813   {
64814     try {
64815       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64816     } catch (std::out_of_range& e) {
64817       {
64818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64819       };
64820     } catch (std::exception& e) {
64821       {
64822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64823       };
64824     } catch (Dali::DaliException e) {
64825       {
64826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64827       };
64828     } catch (...) {
64829       {
64830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64831       };
64832     }
64833   }
64834
64835   jresult = (void *)result;
64836   return jresult;
64837 }
64838
64839
64840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64841   void * jresult ;
64842   float arg1 ;
64843   float arg2 ;
64844   float arg3 ;
64845   float arg4 ;
64846   Dali::Toolkit::Alignment::Padding *result = 0 ;
64847
64848   arg1 = (float)jarg1;
64849   arg2 = (float)jarg2;
64850   arg3 = (float)jarg3;
64851   arg4 = (float)jarg4;
64852   {
64853     try {
64854       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64855     } catch (std::out_of_range& e) {
64856       {
64857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64858       };
64859     } catch (std::exception& e) {
64860       {
64861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64862       };
64863     } catch (Dali::DaliException e) {
64864       {
64865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64866       };
64867     } catch (...) {
64868       {
64869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64870       };
64871     }
64872   }
64873
64874   jresult = (void *)result;
64875   return jresult;
64876 }
64877
64878
64879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64880   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64881   float arg2 ;
64882
64883   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64884   arg2 = (float)jarg2;
64885   if (arg1) (arg1)->left = arg2;
64886 }
64887
64888
64889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64890   float jresult ;
64891   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64892   float result;
64893
64894   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64895   result = (float) ((arg1)->left);
64896   jresult = result;
64897   return jresult;
64898 }
64899
64900
64901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64902   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64903   float arg2 ;
64904
64905   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64906   arg2 = (float)jarg2;
64907   if (arg1) (arg1)->right = arg2;
64908 }
64909
64910
64911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64912   float jresult ;
64913   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64914   float result;
64915
64916   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64917   result = (float) ((arg1)->right);
64918   jresult = result;
64919   return jresult;
64920 }
64921
64922
64923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64924   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64925   float arg2 ;
64926
64927   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64928   arg2 = (float)jarg2;
64929   if (arg1) (arg1)->top = arg2;
64930 }
64931
64932
64933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64934   float jresult ;
64935   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64936   float result;
64937
64938   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64939   result = (float) ((arg1)->top);
64940   jresult = result;
64941   return jresult;
64942 }
64943
64944
64945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64946   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64947   float arg2 ;
64948
64949   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64950   arg2 = (float)jarg2;
64951   if (arg1) (arg1)->bottom = arg2;
64952 }
64953
64954
64955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64956   float jresult ;
64957   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64958   float result;
64959
64960   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64961   result = (float) ((arg1)->bottom);
64962   jresult = result;
64963   return jresult;
64964 }
64965
64966
64967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64968   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64969
64970   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64971   {
64972     try {
64973       delete arg1;
64974     } catch (std::out_of_range& e) {
64975       {
64976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64977       };
64978     } catch (std::exception& e) {
64979       {
64980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64981       };
64982     } catch (Dali::DaliException e) {
64983       {
64984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64985       };
64986     } catch (...) {
64987       {
64988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64989       };
64990     }
64991   }
64992
64993 }
64994
64995
64996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64997   void * jresult ;
64998   Dali::Toolkit::Alignment *result = 0 ;
64999
65000   {
65001     try {
65002       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
65003     } catch (std::out_of_range& e) {
65004       {
65005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65006       };
65007     } catch (std::exception& e) {
65008       {
65009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65010       };
65011     } catch (Dali::DaliException e) {
65012       {
65013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65014       };
65015     } catch (...) {
65016       {
65017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65018       };
65019     }
65020   }
65021
65022   jresult = (void *)result;
65023   return jresult;
65024 }
65025
65026
65027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
65028   void * jresult ;
65029   Dali::Toolkit::Alignment::Type arg1 ;
65030   Dali::Toolkit::Alignment::Type arg2 ;
65031   Dali::Toolkit::Alignment result;
65032
65033   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
65034   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
65035   {
65036     try {
65037       result = Dali::Toolkit::Alignment::New(arg1,arg2);
65038     } catch (std::out_of_range& e) {
65039       {
65040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65041       };
65042     } catch (std::exception& e) {
65043       {
65044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65045       };
65046     } catch (Dali::DaliException e) {
65047       {
65048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65049       };
65050     } catch (...) {
65051       {
65052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65053       };
65054     }
65055   }
65056
65057   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
65058   return jresult;
65059 }
65060
65061
65062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
65063   void * jresult ;
65064   Dali::Toolkit::Alignment::Type arg1 ;
65065   Dali::Toolkit::Alignment result;
65066
65067   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
65068   {
65069     try {
65070       result = Dali::Toolkit::Alignment::New(arg1);
65071     } catch (std::out_of_range& e) {
65072       {
65073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65074       };
65075     } catch (std::exception& e) {
65076       {
65077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65078       };
65079     } catch (Dali::DaliException e) {
65080       {
65081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65082       };
65083     } catch (...) {
65084       {
65085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65086       };
65087     }
65088   }
65089
65090   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
65091   return jresult;
65092 }
65093
65094
65095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
65096   void * jresult ;
65097   Dali::Toolkit::Alignment result;
65098
65099   {
65100     try {
65101       result = Dali::Toolkit::Alignment::New();
65102     } catch (std::out_of_range& e) {
65103       {
65104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65105       };
65106     } catch (std::exception& e) {
65107       {
65108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65109       };
65110     } catch (Dali::DaliException e) {
65111       {
65112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65113       };
65114     } catch (...) {
65115       {
65116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65117       };
65118     }
65119   }
65120
65121   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
65122   return jresult;
65123 }
65124
65125
65126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
65127   void * jresult ;
65128   Dali::Toolkit::Alignment *arg1 = 0 ;
65129   Dali::Toolkit::Alignment *result = 0 ;
65130
65131   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65132   if (!arg1) {
65133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
65134     return 0;
65135   }
65136   {
65137     try {
65138       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
65139     } catch (std::out_of_range& e) {
65140       {
65141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65142       };
65143     } catch (std::exception& e) {
65144       {
65145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65146       };
65147     } catch (Dali::DaliException e) {
65148       {
65149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65150       };
65151     } catch (...) {
65152       {
65153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65154       };
65155     }
65156   }
65157
65158   jresult = (void *)result;
65159   return jresult;
65160 }
65161
65162
65163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
65164   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65165
65166   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65167   {
65168     try {
65169       delete arg1;
65170     } catch (std::out_of_range& e) {
65171       {
65172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65173       };
65174     } catch (std::exception& e) {
65175       {
65176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65177       };
65178     } catch (Dali::DaliException e) {
65179       {
65180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65181       };
65182     } catch (...) {
65183       {
65184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65185       };
65186     }
65187   }
65188
65189 }
65190
65191
65192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
65193   void * jresult ;
65194   Dali::BaseHandle arg1 ;
65195   Dali::BaseHandle *argp1 ;
65196   Dali::Toolkit::Alignment result;
65197
65198   argp1 = (Dali::BaseHandle *)jarg1;
65199   if (!argp1) {
65200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65201     return 0;
65202   }
65203   arg1 = *argp1;
65204   {
65205     try {
65206       result = Dali::Toolkit::Alignment::DownCast(arg1);
65207     } catch (std::out_of_range& e) {
65208       {
65209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65210       };
65211     } catch (std::exception& e) {
65212       {
65213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65214       };
65215     } catch (Dali::DaliException e) {
65216       {
65217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65218       };
65219     } catch (...) {
65220       {
65221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65222       };
65223     }
65224   }
65225
65226   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
65227   return jresult;
65228 }
65229
65230
65231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
65232   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65233   Dali::Toolkit::Alignment::Type arg2 ;
65234
65235   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65236   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
65237   {
65238     try {
65239       (arg1)->SetAlignmentType(arg2);
65240     } catch (std::out_of_range& e) {
65241       {
65242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65243       };
65244     } catch (std::exception& e) {
65245       {
65246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65247       };
65248     } catch (Dali::DaliException e) {
65249       {
65250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65251       };
65252     } catch (...) {
65253       {
65254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65255       };
65256     }
65257   }
65258
65259 }
65260
65261
65262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
65263   int jresult ;
65264   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65265   Dali::Toolkit::Alignment::Type result;
65266
65267   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65268   {
65269     try {
65270       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
65271     } catch (std::out_of_range& e) {
65272       {
65273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65274       };
65275     } catch (std::exception& e) {
65276       {
65277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65278       };
65279     } catch (Dali::DaliException e) {
65280       {
65281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65282       };
65283     } catch (...) {
65284       {
65285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65286       };
65287     }
65288   }
65289
65290   jresult = (int)result;
65291   return jresult;
65292 }
65293
65294
65295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
65296   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65297   Dali::Toolkit::Alignment::Scaling arg2 ;
65298
65299   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65300   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
65301   {
65302     try {
65303       (arg1)->SetScaling(arg2);
65304     } catch (std::out_of_range& e) {
65305       {
65306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65307       };
65308     } catch (std::exception& e) {
65309       {
65310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65311       };
65312     } catch (Dali::DaliException e) {
65313       {
65314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65315       };
65316     } catch (...) {
65317       {
65318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65319       };
65320     }
65321   }
65322
65323 }
65324
65325
65326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
65327   int jresult ;
65328   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65329   Dali::Toolkit::Alignment::Scaling result;
65330
65331   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65332   {
65333     try {
65334       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
65335     } catch (std::out_of_range& e) {
65336       {
65337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65338       };
65339     } catch (std::exception& e) {
65340       {
65341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65342       };
65343     } catch (Dali::DaliException e) {
65344       {
65345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65346       };
65347     } catch (...) {
65348       {
65349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65350       };
65351     }
65352   }
65353
65354   jresult = (int)result;
65355   return jresult;
65356 }
65357
65358
65359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
65360   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65361   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
65362
65363   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65364   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
65365   if (!arg2) {
65366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
65367     return ;
65368   }
65369   {
65370     try {
65371       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
65372     } catch (std::out_of_range& e) {
65373       {
65374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65375       };
65376     } catch (std::exception& e) {
65377       {
65378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65379       };
65380     } catch (Dali::DaliException e) {
65381       {
65382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65383       };
65384     } catch (...) {
65385       {
65386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65387       };
65388     }
65389   }
65390
65391 }
65392
65393
65394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
65395   void * jresult ;
65396   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65397   Dali::Toolkit::Alignment::Padding *result = 0 ;
65398
65399   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65400   {
65401     try {
65402       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
65403     } catch (std::out_of_range& e) {
65404       {
65405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65406       };
65407     } catch (std::exception& e) {
65408       {
65409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65410       };
65411     } catch (Dali::DaliException e) {
65412       {
65413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65414       };
65415     } catch (...) {
65416       {
65417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65418       };
65419     }
65420   }
65421
65422   jresult = (void *)result;
65423   return jresult;
65424 }
65425
65426
65427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
65428   void * jresult ;
65429   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65430   Dali::Toolkit::Alignment *arg2 = 0 ;
65431   Dali::Toolkit::Alignment *result = 0 ;
65432
65433   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65434   arg2 = (Dali::Toolkit::Alignment *)jarg2;
65435   if (!arg2) {
65436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
65437     return 0;
65438   }
65439   {
65440     try {
65441       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
65442     } catch (std::out_of_range& e) {
65443       {
65444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65445       };
65446     } catch (std::exception& e) {
65447       {
65448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65449       };
65450     } catch (Dali::DaliException e) {
65451       {
65452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65453       };
65454     } catch (...) {
65455       {
65456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65457       };
65458     }
65459   }
65460
65461   jresult = (void *)result;
65462   return jresult;
65463 }
65464
65465
65466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
65467   int jresult ;
65468   int result;
65469
65470   result = (int)Dali::Toolkit::Button::Property::DISABLED;
65471   jresult = (int)result;
65472   return jresult;
65473 }
65474
65475
65476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
65477   int jresult ;
65478   int result;
65479
65480   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
65481   jresult = (int)result;
65482   return jresult;
65483 }
65484
65485
65486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
65487   int jresult ;
65488   int result;
65489
65490   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
65491   jresult = (int)result;
65492   return jresult;
65493 }
65494
65495
65496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
65497   int jresult ;
65498   int result;
65499
65500   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
65501   jresult = (int)result;
65502   return jresult;
65503 }
65504
65505
65506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
65507   int jresult ;
65508   int result;
65509
65510   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
65511   jresult = (int)result;
65512   return jresult;
65513 }
65514
65515
65516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
65517   int jresult ;
65518   int result;
65519
65520   result = (int)Dali::Toolkit::Button::Property::SELECTED;
65521   jresult = (int)result;
65522   return jresult;
65523 }
65524
65525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
65526   int jresult ;
65527   int result;
65528
65529   result = (int)Dali::Toolkit::Button::Property::LABEL;
65530   jresult = (int)result;
65531   return jresult;
65532 }
65533
65534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65535   void * jresult ;
65536   Dali::Toolkit::Button::Property *result = 0 ;
65537
65538   {
65539     try {
65540       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
65541     } catch (std::out_of_range& e) {
65542       {
65543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65544       };
65545     } catch (std::exception& e) {
65546       {
65547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65548       };
65549     } catch (Dali::DaliException e) {
65550       {
65551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65552       };
65553     } catch (...) {
65554       {
65555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65556       };
65557     }
65558   }
65559
65560   jresult = (void *)result;
65561   return jresult;
65562 }
65563
65564
65565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65566   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65567
65568   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65569   {
65570     try {
65571       delete arg1;
65572     } catch (std::out_of_range& e) {
65573       {
65574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65575       };
65576     } catch (std::exception& e) {
65577       {
65578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65579       };
65580     } catch (Dali::DaliException e) {
65581       {
65582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65583       };
65584     } catch (...) {
65585       {
65586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65587       };
65588     }
65589   }
65590
65591 }
65592
65593
65594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65595   void * jresult ;
65596   Dali::Toolkit::Button *result = 0 ;
65597
65598   {
65599     try {
65600       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65601     } catch (std::out_of_range& e) {
65602       {
65603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65604       };
65605     } catch (std::exception& e) {
65606       {
65607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65608       };
65609     } catch (Dali::DaliException e) {
65610       {
65611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65612       };
65613     } catch (...) {
65614       {
65615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65616       };
65617     }
65618   }
65619
65620   jresult = (void *)result;
65621   return jresult;
65622 }
65623
65624
65625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65626   void * jresult ;
65627   Dali::Toolkit::Button *arg1 = 0 ;
65628   Dali::Toolkit::Button *result = 0 ;
65629
65630   arg1 = (Dali::Toolkit::Button *)jarg1;
65631   if (!arg1) {
65632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65633     return 0;
65634   }
65635   {
65636     try {
65637       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65638     } catch (std::out_of_range& e) {
65639       {
65640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65641       };
65642     } catch (std::exception& e) {
65643       {
65644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65645       };
65646     } catch (Dali::DaliException e) {
65647       {
65648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65649       };
65650     } catch (...) {
65651       {
65652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65653       };
65654     }
65655   }
65656
65657   jresult = (void *)result;
65658   return jresult;
65659 }
65660
65661
65662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65663   void * jresult ;
65664   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65665   Dali::Toolkit::Button *arg2 = 0 ;
65666   Dali::Toolkit::Button *result = 0 ;
65667
65668   arg1 = (Dali::Toolkit::Button *)jarg1;
65669   arg2 = (Dali::Toolkit::Button *)jarg2;
65670   if (!arg2) {
65671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65672     return 0;
65673   }
65674   {
65675     try {
65676       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65677     } catch (std::out_of_range& e) {
65678       {
65679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65680       };
65681     } catch (std::exception& e) {
65682       {
65683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65684       };
65685     } catch (Dali::DaliException e) {
65686       {
65687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65688       };
65689     } catch (...) {
65690       {
65691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65692       };
65693     }
65694   }
65695
65696   jresult = (void *)result;
65697   return jresult;
65698 }
65699
65700
65701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65702   void * jresult ;
65703   Dali::BaseHandle arg1 ;
65704   Dali::BaseHandle *argp1 ;
65705   Dali::Toolkit::Button result;
65706
65707   argp1 = (Dali::BaseHandle *)jarg1;
65708   if (!argp1) {
65709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65710     return 0;
65711   }
65712   arg1 = *argp1;
65713   {
65714     try {
65715       result = Dali::Toolkit::Button::DownCast(arg1);
65716     } catch (std::out_of_range& e) {
65717       {
65718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65719       };
65720     } catch (std::exception& e) {
65721       {
65722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65723       };
65724     } catch (Dali::DaliException e) {
65725       {
65726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65727       };
65728     } catch (...) {
65729       {
65730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65731       };
65732     }
65733   }
65734
65735   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65736   return jresult;
65737 }
65738
65739
65740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65741   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65742
65743   arg1 = (Dali::Toolkit::Button *)jarg1;
65744   {
65745     try {
65746       delete arg1;
65747     } catch (std::out_of_range& e) {
65748       {
65749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65750       };
65751     } catch (std::exception& e) {
65752       {
65753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65754       };
65755     } catch (Dali::DaliException e) {
65756       {
65757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65758       };
65759     } catch (...) {
65760       {
65761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65762       };
65763     }
65764   }
65765
65766 }
65767
65768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65769   void * jresult ;
65770   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65771   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65772
65773   arg1 = (Dali::Toolkit::Button *)jarg1;
65774   {
65775     try {
65776       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65777     } catch (std::out_of_range& e) {
65778       {
65779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65780       };
65781     } catch (std::exception& e) {
65782       {
65783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65784       };
65785     } catch (Dali::DaliException e) {
65786       {
65787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65788       };
65789     } catch (...) {
65790       {
65791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65792       };
65793     }
65794   }
65795
65796   jresult = (void *)result;
65797   return jresult;
65798 }
65799
65800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65801   void * jresult ;
65802   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65803   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65804
65805   arg1 = (Dali::Toolkit::Button *)jarg1;
65806   {
65807     try {
65808       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65809     } catch (std::out_of_range& e) {
65810       {
65811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65812       };
65813     } catch (std::exception& e) {
65814       {
65815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65816       };
65817     } catch (Dali::DaliException e) {
65818       {
65819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65820       };
65821     } catch (...) {
65822       {
65823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65824       };
65825     }
65826   }
65827
65828   jresult = (void *)result;
65829   return jresult;
65830 }
65831
65832
65833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65834   void * jresult ;
65835   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65836   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65837
65838   arg1 = (Dali::Toolkit::Button *)jarg1;
65839   {
65840     try {
65841       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65842     } catch (std::out_of_range& e) {
65843       {
65844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65845       };
65846     } catch (std::exception& e) {
65847       {
65848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65849       };
65850     } catch (Dali::DaliException e) {
65851       {
65852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65853       };
65854     } catch (...) {
65855       {
65856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65857       };
65858     }
65859   }
65860
65861   jresult = (void *)result;
65862   return jresult;
65863 }
65864
65865
65866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65867   void * jresult ;
65868   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65869   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65870
65871   arg1 = (Dali::Toolkit::Button *)jarg1;
65872   {
65873     try {
65874       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65875     } catch (std::out_of_range& e) {
65876       {
65877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65878       };
65879     } catch (std::exception& e) {
65880       {
65881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65882       };
65883     } catch (Dali::DaliException e) {
65884       {
65885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65886       };
65887     } catch (...) {
65888       {
65889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65890       };
65891     }
65892   }
65893
65894   jresult = (void *)result;
65895   return jresult;
65896 }
65897
65898
65899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65900   void * jresult ;
65901   Dali::Toolkit::CheckBoxButton *result = 0 ;
65902
65903   {
65904     try {
65905       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65906     } catch (std::out_of_range& e) {
65907       {
65908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65909       };
65910     } catch (std::exception& e) {
65911       {
65912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65913       };
65914     } catch (Dali::DaliException e) {
65915       {
65916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65917       };
65918     } catch (...) {
65919       {
65920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65921       };
65922     }
65923   }
65924
65925   jresult = (void *)result;
65926   return jresult;
65927 }
65928
65929
65930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65931   void * jresult ;
65932   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65933   Dali::Toolkit::CheckBoxButton *result = 0 ;
65934
65935   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65936   if (!arg1) {
65937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65938     return 0;
65939   }
65940   {
65941     try {
65942       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65943     } catch (std::out_of_range& e) {
65944       {
65945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65946       };
65947     } catch (std::exception& e) {
65948       {
65949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65950       };
65951     } catch (Dali::DaliException e) {
65952       {
65953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65954       };
65955     } catch (...) {
65956       {
65957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65958       };
65959     }
65960   }
65961
65962   jresult = (void *)result;
65963   return jresult;
65964 }
65965
65966
65967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65968   void * jresult ;
65969   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65970   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65971   Dali::Toolkit::CheckBoxButton *result = 0 ;
65972
65973   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65974   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65975   if (!arg2) {
65976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65977     return 0;
65978   }
65979   {
65980     try {
65981       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65982     } catch (std::out_of_range& e) {
65983       {
65984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65985       };
65986     } catch (std::exception& e) {
65987       {
65988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65989       };
65990     } catch (Dali::DaliException e) {
65991       {
65992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65993       };
65994     } catch (...) {
65995       {
65996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65997       };
65998     }
65999   }
66000
66001   jresult = (void *)result;
66002   return jresult;
66003 }
66004
66005
66006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
66007   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
66008
66009   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
66010   {
66011     try {
66012       delete arg1;
66013     } catch (std::out_of_range& e) {
66014       {
66015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66016       };
66017     } catch (std::exception& e) {
66018       {
66019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66020       };
66021     } catch (Dali::DaliException e) {
66022       {
66023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66024       };
66025     } catch (...) {
66026       {
66027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66028       };
66029     }
66030   }
66031
66032 }
66033
66034
66035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
66036   void * jresult ;
66037   Dali::Toolkit::CheckBoxButton result;
66038
66039   {
66040     try {
66041       result = Dali::Toolkit::CheckBoxButton::New();
66042     } catch (std::out_of_range& e) {
66043       {
66044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66045       };
66046     } catch (std::exception& e) {
66047       {
66048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66049       };
66050     } catch (Dali::DaliException e) {
66051       {
66052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66053       };
66054     } catch (...) {
66055       {
66056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66057       };
66058     }
66059   }
66060
66061   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
66062   return jresult;
66063 }
66064
66065
66066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
66067   void * jresult ;
66068   Dali::BaseHandle arg1 ;
66069   Dali::BaseHandle *argp1 ;
66070   Dali::Toolkit::CheckBoxButton result;
66071
66072   argp1 = (Dali::BaseHandle *)jarg1;
66073   if (!argp1) {
66074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66075     return 0;
66076   }
66077   arg1 = *argp1;
66078   {
66079     try {
66080       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
66081     } catch (std::out_of_range& e) {
66082       {
66083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66084       };
66085     } catch (std::exception& e) {
66086       {
66087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66088       };
66089     } catch (Dali::DaliException e) {
66090       {
66091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66092       };
66093     } catch (...) {
66094       {
66095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66096       };
66097     }
66098   }
66099
66100   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
66101   return jresult;
66102 }
66103
66104
66105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
66106   int jresult ;
66107   int result;
66108
66109   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
66110   jresult = (int)result;
66111   return jresult;
66112 }
66113
66114
66115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
66116   int jresult ;
66117   int result;
66118
66119   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
66120   jresult = (int)result;
66121   return jresult;
66122 }
66123
66124
66125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
66126   int jresult ;
66127   int result;
66128
66129   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
66130   jresult = (int)result;
66131   return jresult;
66132 }
66133
66134
66135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
66136   int jresult ;
66137   int result;
66138
66139   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
66140   jresult = (int)result;
66141   return jresult;
66142 }
66143
66144
66145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
66146   int jresult ;
66147   int result;
66148
66149   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
66150   jresult = (int)result;
66151   return jresult;
66152 }
66153
66154
66155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
66156   void * jresult ;
66157   Dali::Toolkit::PushButton::Property *result = 0 ;
66158
66159   {
66160     try {
66161       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
66162     } catch (std::out_of_range& e) {
66163       {
66164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66165       };
66166     } catch (std::exception& e) {
66167       {
66168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66169       };
66170     } catch (Dali::DaliException e) {
66171       {
66172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66173       };
66174     } catch (...) {
66175       {
66176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66177       };
66178     }
66179   }
66180
66181   jresult = (void *)result;
66182   return jresult;
66183 }
66184
66185
66186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
66187   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
66188
66189   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
66190   {
66191     try {
66192       delete arg1;
66193     } catch (std::out_of_range& e) {
66194       {
66195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66196       };
66197     } catch (std::exception& e) {
66198       {
66199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66200       };
66201     } catch (Dali::DaliException e) {
66202       {
66203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66204       };
66205     } catch (...) {
66206       {
66207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66208       };
66209     }
66210   }
66211
66212 }
66213
66214
66215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
66216   void * jresult ;
66217   Dali::Toolkit::PushButton *result = 0 ;
66218
66219   {
66220     try {
66221       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
66222     } catch (std::out_of_range& e) {
66223       {
66224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66225       };
66226     } catch (std::exception& e) {
66227       {
66228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66229       };
66230     } catch (Dali::DaliException e) {
66231       {
66232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66233       };
66234     } catch (...) {
66235       {
66236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66237       };
66238     }
66239   }
66240
66241   jresult = (void *)result;
66242   return jresult;
66243 }
66244
66245
66246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
66247   void * jresult ;
66248   Dali::Toolkit::PushButton *arg1 = 0 ;
66249   Dali::Toolkit::PushButton *result = 0 ;
66250
66251   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66252   if (!arg1) {
66253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66254     return 0;
66255   }
66256   {
66257     try {
66258       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
66259     } catch (std::out_of_range& e) {
66260       {
66261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66262       };
66263     } catch (std::exception& e) {
66264       {
66265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66266       };
66267     } catch (Dali::DaliException e) {
66268       {
66269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66270       };
66271     } catch (...) {
66272       {
66273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66274       };
66275     }
66276   }
66277
66278   jresult = (void *)result;
66279   return jresult;
66280 }
66281
66282
66283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
66284   void * jresult ;
66285   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66286   Dali::Toolkit::PushButton *arg2 = 0 ;
66287   Dali::Toolkit::PushButton *result = 0 ;
66288
66289   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66290   arg2 = (Dali::Toolkit::PushButton *)jarg2;
66291   if (!arg2) {
66292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66293     return 0;
66294   }
66295   {
66296     try {
66297       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
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_delete_PushButton(void * jarg1) {
66323   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66324
66325   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66326   {
66327     try {
66328       delete arg1;
66329     } catch (std::out_of_range& e) {
66330       {
66331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66332       };
66333     } catch (std::exception& e) {
66334       {
66335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66336       };
66337     } catch (Dali::DaliException e) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66340       };
66341     } catch (...) {
66342       {
66343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66344       };
66345     }
66346   }
66347
66348 }
66349
66350
66351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
66352   void * jresult ;
66353   Dali::Toolkit::PushButton result;
66354
66355   {
66356     try {
66357       result = Dali::Toolkit::PushButton::New();
66358     } catch (std::out_of_range& e) {
66359       {
66360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66361       };
66362     } catch (std::exception& e) {
66363       {
66364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66365       };
66366     } catch (Dali::DaliException e) {
66367       {
66368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66369       };
66370     } catch (...) {
66371       {
66372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66373       };
66374     }
66375   }
66376
66377   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66378   return jresult;
66379 }
66380
66381
66382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
66383   void * jresult ;
66384   Dali::BaseHandle arg1 ;
66385   Dali::BaseHandle *argp1 ;
66386   Dali::Toolkit::PushButton result;
66387
66388   argp1 = (Dali::BaseHandle *)jarg1;
66389   if (!argp1) {
66390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66391     return 0;
66392   }
66393   arg1 = *argp1;
66394   {
66395     try {
66396       result = Dali::Toolkit::PushButton::DownCast(arg1);
66397     } catch (std::out_of_range& e) {
66398       {
66399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66400       };
66401     } catch (std::exception& e) {
66402       {
66403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66404       };
66405     } catch (Dali::DaliException e) {
66406       {
66407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66408       };
66409     } catch (...) {
66410       {
66411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66412       };
66413     }
66414   }
66415
66416   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66417   return jresult;
66418 }
66419
66420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66421   void * jresult ;
66422   Dali::Toolkit::RadioButton *result = 0 ;
66423
66424   {
66425     try {
66426       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66427     } catch (std::out_of_range& e) {
66428       {
66429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66430       };
66431     } catch (std::exception& e) {
66432       {
66433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66434       };
66435     } catch (Dali::DaliException e) {
66436       {
66437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66438       };
66439     } catch (...) {
66440       {
66441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66442       };
66443     }
66444   }
66445
66446   jresult = (void *)result;
66447   return jresult;
66448 }
66449
66450
66451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66452   void * jresult ;
66453   Dali::Toolkit::RadioButton *arg1 = 0 ;
66454   Dali::Toolkit::RadioButton *result = 0 ;
66455
66456   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66457   if (!arg1) {
66458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66459     return 0;
66460   }
66461   {
66462     try {
66463       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66464     } catch (std::out_of_range& e) {
66465       {
66466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66467       };
66468     } catch (std::exception& e) {
66469       {
66470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66471       };
66472     } catch (Dali::DaliException e) {
66473       {
66474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66475       };
66476     } catch (...) {
66477       {
66478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66479       };
66480     }
66481   }
66482
66483   jresult = (void *)result;
66484   return jresult;
66485 }
66486
66487
66488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66489   void * jresult ;
66490   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66491   Dali::Toolkit::RadioButton *arg2 = 0 ;
66492   Dali::Toolkit::RadioButton *result = 0 ;
66493
66494   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66495   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66496   if (!arg2) {
66497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66498     return 0;
66499   }
66500   {
66501     try {
66502       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66503     } catch (std::out_of_range& e) {
66504       {
66505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66506       };
66507     } catch (std::exception& e) {
66508       {
66509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66510       };
66511     } catch (Dali::DaliException e) {
66512       {
66513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66514       };
66515     } catch (...) {
66516       {
66517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66518       };
66519     }
66520   }
66521
66522   jresult = (void *)result;
66523   return jresult;
66524 }
66525
66526
66527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66528   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66529
66530   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66531   {
66532     try {
66533       delete arg1;
66534     } catch (std::out_of_range& e) {
66535       {
66536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66537       };
66538     } catch (std::exception& e) {
66539       {
66540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66541       };
66542     } catch (Dali::DaliException e) {
66543       {
66544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66545       };
66546     } catch (...) {
66547       {
66548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66549       };
66550     }
66551   }
66552
66553 }
66554
66555
66556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66557   void * jresult ;
66558   Dali::Toolkit::RadioButton result;
66559
66560   {
66561     try {
66562       result = Dali::Toolkit::RadioButton::New();
66563     } catch (std::out_of_range& e) {
66564       {
66565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66566       };
66567     } catch (std::exception& e) {
66568       {
66569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66570       };
66571     } catch (Dali::DaliException e) {
66572       {
66573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66574       };
66575     } catch (...) {
66576       {
66577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66578       };
66579     }
66580   }
66581
66582   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66583   return jresult;
66584 }
66585
66586
66587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66588   void * jresult ;
66589   std::string *arg1 = 0 ;
66590   Dali::Toolkit::RadioButton result;
66591
66592   if (!jarg1) {
66593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66594     return 0;
66595   }
66596   std::string arg1_str(jarg1);
66597   arg1 = &arg1_str;
66598   {
66599     try {
66600       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66601     } catch (std::out_of_range& e) {
66602       {
66603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66604       };
66605     } catch (std::exception& e) {
66606       {
66607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66608       };
66609     } catch (Dali::DaliException e) {
66610       {
66611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66612       };
66613     } catch (...) {
66614       {
66615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66616       };
66617     }
66618   }
66619
66620   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66621
66622   //argout typemap for const std::string&
66623
66624   return jresult;
66625 }
66626
66627
66628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66629   void * jresult ;
66630   Dali::BaseHandle arg1 ;
66631   Dali::BaseHandle *argp1 ;
66632   Dali::Toolkit::RadioButton result;
66633
66634   argp1 = (Dali::BaseHandle *)jarg1;
66635   if (!argp1) {
66636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66637     return 0;
66638   }
66639   arg1 = *argp1;
66640   {
66641     try {
66642       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66643     } catch (std::out_of_range& e) {
66644       {
66645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66646       };
66647     } catch (std::exception& e) {
66648       {
66649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66650       };
66651     } catch (Dali::DaliException e) {
66652       {
66653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66654       };
66655     } catch (...) {
66656       {
66657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66658       };
66659     }
66660   }
66661
66662   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66663   return jresult;
66664 }
66665
66666
66667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66668   int jresult ;
66669   int result;
66670
66671   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66672   jresult = (int)result;
66673   return jresult;
66674 }
66675
66676
66677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66678   int jresult ;
66679   int result;
66680
66681   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66682   jresult = (int)result;
66683   return jresult;
66684 }
66685
66686
66687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66688   int jresult ;
66689   int result;
66690
66691   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66692   jresult = (int)result;
66693   return jresult;
66694 }
66695
66696
66697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66698   int jresult ;
66699   int result;
66700
66701   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66702   jresult = (int)result;
66703   return jresult;
66704 }
66705
66706
66707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66708   int jresult ;
66709   int result;
66710
66711   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66712   jresult = (int)result;
66713   return jresult;
66714 }
66715
66716
66717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66718   int jresult ;
66719   int result;
66720
66721   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66722   jresult = (int)result;
66723   return jresult;
66724 }
66725
66726
66727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66728   void * jresult ;
66729   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66730
66731   {
66732     try {
66733       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66734     } catch (std::out_of_range& e) {
66735       {
66736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66737       };
66738     } catch (std::exception& e) {
66739       {
66740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66741       };
66742     } catch (Dali::DaliException e) {
66743       {
66744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66745       };
66746     } catch (...) {
66747       {
66748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66749       };
66750     }
66751   }
66752
66753   jresult = (void *)result;
66754   return jresult;
66755 }
66756
66757
66758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66759   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66760
66761   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66762   {
66763     try {
66764       delete arg1;
66765     } catch (std::out_of_range& e) {
66766       {
66767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66768       };
66769     } catch (std::exception& e) {
66770       {
66771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66772       };
66773     } catch (Dali::DaliException e) {
66774       {
66775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66776       };
66777     } catch (...) {
66778       {
66779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66780       };
66781     }
66782   }
66783
66784 }
66785
66786
66787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66788   int jresult ;
66789   int result;
66790
66791   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66792   jresult = (int)result;
66793   return jresult;
66794 }
66795
66796
66797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66798   int jresult ;
66799   int result;
66800
66801   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66802   jresult = (int)result;
66803   return jresult;
66804 }
66805
66806
66807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66808   int jresult ;
66809   int result;
66810
66811   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66812   jresult = (int)result;
66813   return jresult;
66814 }
66815
66816
66817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66818   void * jresult ;
66819   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66820
66821   {
66822     try {
66823       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66824     } catch (std::out_of_range& e) {
66825       {
66826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66827       };
66828     } catch (std::exception& e) {
66829       {
66830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66831       };
66832     } catch (Dali::DaliException e) {
66833       {
66834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66835       };
66836     } catch (...) {
66837       {
66838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66839       };
66840     }
66841   }
66842
66843   jresult = (void *)result;
66844   return jresult;
66845 }
66846
66847
66848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66849   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66850
66851   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66852   {
66853     try {
66854       delete arg1;
66855     } catch (std::out_of_range& e) {
66856       {
66857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66858       };
66859     } catch (std::exception& e) {
66860       {
66861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66862       };
66863     } catch (Dali::DaliException e) {
66864       {
66865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66866       };
66867     } catch (...) {
66868       {
66869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66870       };
66871     }
66872   }
66873
66874 }
66875
66876
66877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66878   void * jresult ;
66879   Dali::Toolkit::FlexContainer *result = 0 ;
66880
66881   {
66882     try {
66883       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66884     } catch (std::out_of_range& e) {
66885       {
66886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66887       };
66888     } catch (std::exception& e) {
66889       {
66890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66891       };
66892     } catch (Dali::DaliException e) {
66893       {
66894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66895       };
66896     } catch (...) {
66897       {
66898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66899       };
66900     }
66901   }
66902
66903   jresult = (void *)result;
66904   return jresult;
66905 }
66906
66907
66908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66909   void * jresult ;
66910   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66911   Dali::Toolkit::FlexContainer *result = 0 ;
66912
66913   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66914   if (!arg1) {
66915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66916     return 0;
66917   }
66918   {
66919     try {
66920       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66921     } catch (std::out_of_range& e) {
66922       {
66923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66924       };
66925     } catch (std::exception& e) {
66926       {
66927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66928       };
66929     } catch (Dali::DaliException e) {
66930       {
66931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66932       };
66933     } catch (...) {
66934       {
66935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66936       };
66937     }
66938   }
66939
66940   jresult = (void *)result;
66941   return jresult;
66942 }
66943
66944
66945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66946   void * jresult ;
66947   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66948   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66949   Dali::Toolkit::FlexContainer *result = 0 ;
66950
66951   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66952   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66953   if (!arg2) {
66954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66955     return 0;
66956   }
66957   {
66958     try {
66959       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66960     } catch (std::out_of_range& e) {
66961       {
66962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66963       };
66964     } catch (std::exception& e) {
66965       {
66966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66967       };
66968     } catch (Dali::DaliException e) {
66969       {
66970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66971       };
66972     } catch (...) {
66973       {
66974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66975       };
66976     }
66977   }
66978
66979   jresult = (void *)result;
66980   return jresult;
66981 }
66982
66983
66984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66985   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66986
66987   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66988   {
66989     try {
66990       delete arg1;
66991     } catch (std::out_of_range& e) {
66992       {
66993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66994       };
66995     } catch (std::exception& e) {
66996       {
66997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66998       };
66999     } catch (Dali::DaliException e) {
67000       {
67001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67002       };
67003     } catch (...) {
67004       {
67005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67006       };
67007     }
67008   }
67009
67010 }
67011
67012
67013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
67014   void * jresult ;
67015   Dali::Toolkit::FlexContainer result;
67016
67017   {
67018     try {
67019       result = Dali::Toolkit::FlexContainer::New();
67020     } catch (std::out_of_range& e) {
67021       {
67022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67023       };
67024     } catch (std::exception& e) {
67025       {
67026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67027       };
67028     } catch (Dali::DaliException e) {
67029       {
67030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67031       };
67032     } catch (...) {
67033       {
67034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67035       };
67036     }
67037   }
67038
67039   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67040   return jresult;
67041 }
67042
67043
67044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
67045   void * jresult ;
67046   Dali::BaseHandle arg1 ;
67047   Dali::BaseHandle *argp1 ;
67048   Dali::Toolkit::FlexContainer result;
67049
67050   argp1 = (Dali::BaseHandle *)jarg1;
67051   if (!argp1) {
67052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67053     return 0;
67054   }
67055   arg1 = *argp1;
67056   {
67057     try {
67058       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
67059     } catch (std::out_of_range& e) {
67060       {
67061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67062       };
67063     } catch (std::exception& e) {
67064       {
67065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67066       };
67067     } catch (Dali::DaliException e) {
67068       {
67069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67070       };
67071     } catch (...) {
67072       {
67073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67074       };
67075     }
67076   }
67077
67078   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67079   return jresult;
67080 }
67081
67082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
67083   int jresult ;
67084   int result;
67085
67086   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
67087   jresult = (int)result;
67088   return jresult;
67089 }
67090
67091
67092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
67093   int jresult ;
67094   int result;
67095
67096   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
67097   jresult = (int)result;
67098   return jresult;
67099 }
67100
67101
67102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
67103   int jresult ;
67104   int result;
67105
67106   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
67107   jresult = (int)result;
67108   return jresult;
67109 }
67110
67111
67112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
67113   void * jresult ;
67114   Dali::Toolkit::ImageView::Property *result = 0 ;
67115
67116   {
67117     try {
67118       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
67119     } catch (std::out_of_range& e) {
67120       {
67121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67122       };
67123     } catch (std::exception& e) {
67124       {
67125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67126       };
67127     } catch (Dali::DaliException e) {
67128       {
67129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67130       };
67131     } catch (...) {
67132       {
67133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67134       };
67135     }
67136   }
67137
67138   jresult = (void *)result;
67139   return jresult;
67140 }
67141
67142
67143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
67144   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
67145
67146   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
67147   {
67148     try {
67149       delete arg1;
67150     } catch (std::out_of_range& e) {
67151       {
67152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67153       };
67154     } catch (std::exception& e) {
67155       {
67156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67157       };
67158     } catch (Dali::DaliException e) {
67159       {
67160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67161       };
67162     } catch (...) {
67163       {
67164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67165       };
67166     }
67167   }
67168
67169 }
67170
67171
67172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
67173   void * jresult ;
67174   Dali::Toolkit::ImageView *result = 0 ;
67175
67176   {
67177     try {
67178       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
67179     } catch (std::out_of_range& e) {
67180       {
67181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67182       };
67183     } catch (std::exception& e) {
67184       {
67185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67186       };
67187     } catch (Dali::DaliException e) {
67188       {
67189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67190       };
67191     } catch (...) {
67192       {
67193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67194       };
67195     }
67196   }
67197
67198   jresult = (void *)result;
67199   return jresult;
67200 }
67201
67202
67203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
67204   void * jresult ;
67205   Dali::Toolkit::ImageView result;
67206
67207   {
67208     try {
67209       result = Dali::Toolkit::ImageView::New();
67210     } catch (std::out_of_range& e) {
67211       {
67212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67213       };
67214     } catch (std::exception& e) {
67215       {
67216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67217       };
67218     } catch (Dali::DaliException e) {
67219       {
67220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67221       };
67222     } catch (...) {
67223       {
67224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67225       };
67226     }
67227   }
67228
67229   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67230   return jresult;
67231 }
67232
67233
67234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
67235   void * jresult ;
67236   std::string *arg1 = 0 ;
67237   Dali::Toolkit::ImageView result;
67238
67239   if (!jarg1) {
67240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67241     return 0;
67242   }
67243   std::string arg1_str(jarg1);
67244   arg1 = &arg1_str;
67245   {
67246     try {
67247       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
67248     } catch (std::out_of_range& e) {
67249       {
67250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67251       };
67252     } catch (std::exception& e) {
67253       {
67254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67255       };
67256     } catch (Dali::DaliException e) {
67257       {
67258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67259       };
67260     } catch (...) {
67261       {
67262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67263       };
67264     }
67265   }
67266
67267   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67268
67269   //argout typemap for const std::string&
67270
67271   return jresult;
67272 }
67273
67274
67275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67276   void * jresult ;
67277   std::string *arg1 = 0 ;
67278   Dali::ImageDimensions arg2 ;
67279   Dali::ImageDimensions *argp2 ;
67280   Dali::Toolkit::ImageView result;
67281
67282   if (!jarg1) {
67283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67284     return 0;
67285   }
67286   std::string arg1_str(jarg1);
67287   arg1 = &arg1_str;
67288   argp2 = (Dali::ImageDimensions *)jarg2;
67289   if (!argp2) {
67290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67291     return 0;
67292   }
67293   arg2 = *argp2;
67294   {
67295     try {
67296       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67297     } catch (std::out_of_range& e) {
67298       {
67299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67300       };
67301     } catch (std::exception& e) {
67302       {
67303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67304       };
67305     } catch (Dali::DaliException e) {
67306       {
67307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67308       };
67309     } catch (...) {
67310       {
67311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67312       };
67313     }
67314   }
67315
67316   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67317
67318   //argout typemap for const std::string&
67319
67320   return jresult;
67321 }
67322
67323
67324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
67325   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67326
67327   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67328   {
67329     try {
67330       delete arg1;
67331     } catch (std::out_of_range& e) {
67332       {
67333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67334       };
67335     } catch (std::exception& e) {
67336       {
67337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67338       };
67339     } catch (Dali::DaliException e) {
67340       {
67341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67342       };
67343     } catch (...) {
67344       {
67345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67346       };
67347     }
67348   }
67349
67350 }
67351
67352
67353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
67354   void * jresult ;
67355   Dali::Toolkit::ImageView *arg1 = 0 ;
67356   Dali::Toolkit::ImageView *result = 0 ;
67357
67358   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67359   if (!arg1) {
67360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67361     return 0;
67362   }
67363   {
67364     try {
67365       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67366     } catch (std::out_of_range& e) {
67367       {
67368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67369       };
67370     } catch (std::exception& e) {
67371       {
67372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67373       };
67374     } catch (Dali::DaliException e) {
67375       {
67376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67377       };
67378     } catch (...) {
67379       {
67380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67381       };
67382     }
67383   }
67384
67385   jresult = (void *)result;
67386   return jresult;
67387 }
67388
67389
67390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
67391   void * jresult ;
67392   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67393   Dali::Toolkit::ImageView *arg2 = 0 ;
67394   Dali::Toolkit::ImageView *result = 0 ;
67395
67396   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67397   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67398   if (!arg2) {
67399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67400     return 0;
67401   }
67402   {
67403     try {
67404       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67405     } catch (std::out_of_range& e) {
67406       {
67407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67408       };
67409     } catch (std::exception& e) {
67410       {
67411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67412       };
67413     } catch (Dali::DaliException e) {
67414       {
67415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67416       };
67417     } catch (...) {
67418       {
67419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67420       };
67421     }
67422   }
67423
67424   jresult = (void *)result;
67425   return jresult;
67426 }
67427
67428
67429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67430   void * jresult ;
67431   Dali::BaseHandle arg1 ;
67432   Dali::BaseHandle *argp1 ;
67433   Dali::Toolkit::ImageView result;
67434
67435   argp1 = (Dali::BaseHandle *)jarg1;
67436   if (!argp1) {
67437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67438     return 0;
67439   }
67440   arg1 = *argp1;
67441   {
67442     try {
67443       result = Dali::Toolkit::ImageView::DownCast(arg1);
67444     } catch (std::out_of_range& e) {
67445       {
67446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67447       };
67448     } catch (std::exception& e) {
67449       {
67450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67451       };
67452     } catch (Dali::DaliException e) {
67453       {
67454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67455       };
67456     } catch (...) {
67457       {
67458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67459       };
67460     }
67461   }
67462
67463   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67464   return jresult;
67465 }
67466
67467
67468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67469   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67470   std::string *arg2 = 0 ;
67471
67472   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67473   if (!jarg2) {
67474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67475     return ;
67476   }
67477   std::string arg2_str(jarg2);
67478   arg2 = &arg2_str;
67479   {
67480     try {
67481       (arg1)->SetImage((std::string const &)*arg2);
67482     } catch (std::out_of_range& e) {
67483       {
67484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67485       };
67486     } catch (std::exception& e) {
67487       {
67488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67489       };
67490     } catch (Dali::DaliException e) {
67491       {
67492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67493       };
67494     } catch (...) {
67495       {
67496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67497       };
67498     }
67499   }
67500
67501
67502   //argout typemap for const std::string&
67503
67504 }
67505
67506
67507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67508   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67509   std::string *arg2 = 0 ;
67510   Dali::ImageDimensions arg3 ;
67511   Dali::ImageDimensions *argp3 ;
67512
67513   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67514   if (!jarg2) {
67515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67516     return ;
67517   }
67518   std::string arg2_str(jarg2);
67519   arg2 = &arg2_str;
67520   argp3 = (Dali::ImageDimensions *)jarg3;
67521   if (!argp3) {
67522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67523     return ;
67524   }
67525   arg3 = *argp3;
67526   {
67527     try {
67528       (arg1)->SetImage((std::string const &)*arg2,arg3);
67529     } catch (std::out_of_range& e) {
67530       {
67531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67532       };
67533     } catch (std::exception& e) {
67534       {
67535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67536       };
67537     } catch (Dali::DaliException e) {
67538       {
67539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67540       };
67541     } catch (...) {
67542       {
67543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67544       };
67545     }
67546   }
67547
67548
67549   //argout typemap for const std::string&
67550
67551 }
67552
67553
67554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67555   int jresult ;
67556   int result;
67557
67558   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67559   jresult = (int)result;
67560   return jresult;
67561 }
67562
67563
67564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67565   int jresult ;
67566   int result;
67567
67568   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67569   jresult = (int)result;
67570   return jresult;
67571 }
67572
67573
67574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67575   int jresult ;
67576   int result;
67577
67578   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67579   jresult = (int)result;
67580   return jresult;
67581 }
67582
67583
67584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67585   int jresult ;
67586   int result;
67587
67588   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67589   jresult = (int)result;
67590   return jresult;
67591 }
67592
67593
67594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67595   int jresult ;
67596   int result;
67597
67598   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67599   jresult = (int)result;
67600   return jresult;
67601 }
67602
67603
67604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67605   int jresult ;
67606   int result;
67607
67608   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67609   jresult = (int)result;
67610   return jresult;
67611 }
67612
67613
67614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67615   int jresult ;
67616   int result;
67617
67618   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67619   jresult = (int)result;
67620   return jresult;
67621 }
67622
67623
67624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67625   int jresult ;
67626   int result;
67627
67628   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67629   jresult = (int)result;
67630   return jresult;
67631 }
67632
67633
67634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67635   void * jresult ;
67636   Dali::Toolkit::Model3dView::Property *result = 0 ;
67637
67638   {
67639     try {
67640       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67641     } catch (std::out_of_range& e) {
67642       {
67643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67644       };
67645     } catch (std::exception& e) {
67646       {
67647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67648       };
67649     } catch (Dali::DaliException e) {
67650       {
67651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67652       };
67653     } catch (...) {
67654       {
67655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67656       };
67657     }
67658   }
67659
67660   jresult = (void *)result;
67661   return jresult;
67662 }
67663
67664
67665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67666   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67667
67668   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67669   {
67670     try {
67671       delete arg1;
67672     } catch (std::out_of_range& e) {
67673       {
67674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67675       };
67676     } catch (std::exception& e) {
67677       {
67678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67679       };
67680     } catch (Dali::DaliException e) {
67681       {
67682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67683       };
67684     } catch (...) {
67685       {
67686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67687       };
67688     }
67689   }
67690
67691 }
67692
67693
67694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67695   void * jresult ;
67696   Dali::Toolkit::Model3dView result;
67697
67698   {
67699     try {
67700       result = Dali::Toolkit::Model3dView::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::Model3dView((const Dali::Toolkit::Model3dView &)result);
67721   return jresult;
67722 }
67723
67724
67725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67726   void * jresult ;
67727   std::string *arg1 = 0 ;
67728   std::string *arg2 = 0 ;
67729   std::string *arg3 = 0 ;
67730   Dali::Toolkit::Model3dView result;
67731
67732   if (!jarg1) {
67733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67734     return 0;
67735   }
67736   std::string arg1_str(jarg1);
67737   arg1 = &arg1_str;
67738   if (!jarg2) {
67739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67740     return 0;
67741   }
67742   std::string arg2_str(jarg2);
67743   arg2 = &arg2_str;
67744   if (!jarg3) {
67745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67746     return 0;
67747   }
67748   std::string arg3_str(jarg3);
67749   arg3 = &arg3_str;
67750   {
67751     try {
67752       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67753     } catch (std::out_of_range& e) {
67754       {
67755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67756       };
67757     } catch (std::exception& e) {
67758       {
67759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67760       };
67761     } catch (Dali::DaliException e) {
67762       {
67763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67764       };
67765     } catch (...) {
67766       {
67767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67768       };
67769     }
67770   }
67771
67772   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67773
67774   //argout typemap for const std::string&
67775
67776
67777   //argout typemap for const std::string&
67778
67779
67780   //argout typemap for const std::string&
67781
67782   return jresult;
67783 }
67784
67785
67786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67787   void * jresult ;
67788   Dali::Toolkit::Model3dView *result = 0 ;
67789
67790   {
67791     try {
67792       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67793     } catch (std::out_of_range& e) {
67794       {
67795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67796       };
67797     } catch (std::exception& e) {
67798       {
67799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67800       };
67801     } catch (Dali::DaliException e) {
67802       {
67803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67804       };
67805     } catch (...) {
67806       {
67807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67808       };
67809     }
67810   }
67811
67812   jresult = (void *)result;
67813   return jresult;
67814 }
67815
67816
67817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67818   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67819
67820   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67821   {
67822     try {
67823       delete arg1;
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_new_Model3dView__SWIG_1(void * jarg1) {
67847   void * jresult ;
67848   Dali::Toolkit::Model3dView *arg1 = 0 ;
67849   Dali::Toolkit::Model3dView *result = 0 ;
67850
67851   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67852   if (!arg1) {
67853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67854     return 0;
67855   }
67856   {
67857     try {
67858       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67859     } catch (std::out_of_range& e) {
67860       {
67861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67862       };
67863     } catch (std::exception& e) {
67864       {
67865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67866       };
67867     } catch (Dali::DaliException e) {
67868       {
67869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67870       };
67871     } catch (...) {
67872       {
67873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67874       };
67875     }
67876   }
67877
67878   jresult = (void *)result;
67879   return jresult;
67880 }
67881
67882
67883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67884   void * jresult ;
67885   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67886   Dali::Toolkit::Model3dView *arg2 = 0 ;
67887   Dali::Toolkit::Model3dView *result = 0 ;
67888
67889   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67890   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67891   if (!arg2) {
67892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67893     return 0;
67894   }
67895   {
67896     try {
67897       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67898     } catch (std::out_of_range& e) {
67899       {
67900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67901       };
67902     } catch (std::exception& e) {
67903       {
67904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67905       };
67906     } catch (Dali::DaliException e) {
67907       {
67908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67909       };
67910     } catch (...) {
67911       {
67912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67913       };
67914     }
67915   }
67916
67917   jresult = (void *)result;
67918   return jresult;
67919 }
67920
67921
67922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67923   void * jresult ;
67924   Dali::BaseHandle arg1 ;
67925   Dali::BaseHandle *argp1 ;
67926   Dali::Toolkit::Model3dView result;
67927
67928   argp1 = (Dali::BaseHandle *)jarg1;
67929   if (!argp1) {
67930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67931     return 0;
67932   }
67933   arg1 = *argp1;
67934   {
67935     try {
67936       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67937     } catch (std::out_of_range& e) {
67938       {
67939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67940       };
67941     } catch (std::exception& e) {
67942       {
67943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67944       };
67945     } catch (Dali::DaliException e) {
67946       {
67947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67948       };
67949     } catch (...) {
67950       {
67951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67952       };
67953     }
67954   }
67955
67956   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67957   return jresult;
67958 }
67959
67960
67961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67962   int jresult ;
67963   int result;
67964
67965   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67966   jresult = (int)result;
67967   return jresult;
67968 }
67969
67970
67971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67972   int jresult ;
67973   int result;
67974
67975   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67976   jresult = (int)result;
67977   return jresult;
67978 }
67979
67980
67981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67982   int jresult ;
67983   int result;
67984
67985   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67986   jresult = (int)result;
67987   return jresult;
67988 }
67989
67990
67991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67992   int jresult ;
67993   int result;
67994
67995   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67996   jresult = (int)result;
67997   return jresult;
67998 }
67999
68000
68001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
68002   int jresult ;
68003   int result;
68004
68005   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
68006   jresult = (int)result;
68007   return jresult;
68008 }
68009
68010
68011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
68012   int jresult ;
68013   int result;
68014
68015   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
68016   jresult = (int)result;
68017   return jresult;
68018 }
68019
68020
68021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
68022   int jresult ;
68023   int result;
68024
68025   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
68026   jresult = (int)result;
68027   return jresult;
68028 }
68029
68030
68031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
68032   int jresult ;
68033   int result;
68034
68035   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
68036   jresult = (int)result;
68037   return jresult;
68038 }
68039
68040
68041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
68042   int jresult ;
68043   int result;
68044
68045   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
68046   jresult = (int)result;
68047   return jresult;
68048 }
68049
68050
68051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
68052   void * jresult ;
68053   Dali::Toolkit::ScrollBar::Property *result = 0 ;
68054
68055   {
68056     try {
68057       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
68058     } catch (std::out_of_range& e) {
68059       {
68060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68061       };
68062     } catch (std::exception& e) {
68063       {
68064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68065       };
68066     } catch (Dali::DaliException e) {
68067       {
68068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68069       };
68070     } catch (...) {
68071       {
68072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68073       };
68074     }
68075   }
68076
68077   jresult = (void *)result;
68078   return jresult;
68079 }
68080
68081
68082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
68083   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
68084
68085   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
68086   {
68087     try {
68088       delete arg1;
68089     } catch (std::out_of_range& e) {
68090       {
68091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68092       };
68093     } catch (std::exception& e) {
68094       {
68095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68096       };
68097     } catch (Dali::DaliException e) {
68098       {
68099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68100       };
68101     } catch (...) {
68102       {
68103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68104       };
68105     }
68106   }
68107
68108 }
68109
68110
68111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
68112   void * jresult ;
68113   Dali::Toolkit::ScrollBar *result = 0 ;
68114
68115   {
68116     try {
68117       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
68118     } catch (std::out_of_range& e) {
68119       {
68120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68121       };
68122     } catch (std::exception& e) {
68123       {
68124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68125       };
68126     } catch (Dali::DaliException e) {
68127       {
68128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68129       };
68130     } catch (...) {
68131       {
68132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68133       };
68134     }
68135   }
68136
68137   jresult = (void *)result;
68138   return jresult;
68139 }
68140
68141
68142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
68143   void * jresult ;
68144   Dali::Toolkit::ScrollBar *arg1 = 0 ;
68145   Dali::Toolkit::ScrollBar *result = 0 ;
68146
68147   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68148   if (!arg1) {
68149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68150     return 0;
68151   }
68152   {
68153     try {
68154       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
68155     } catch (std::out_of_range& e) {
68156       {
68157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68158       };
68159     } catch (std::exception& e) {
68160       {
68161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68162       };
68163     } catch (Dali::DaliException e) {
68164       {
68165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68166       };
68167     } catch (...) {
68168       {
68169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68170       };
68171     }
68172   }
68173
68174   jresult = (void *)result;
68175   return jresult;
68176 }
68177
68178
68179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
68180   void * jresult ;
68181   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68182   Dali::Toolkit::ScrollBar *arg2 = 0 ;
68183   Dali::Toolkit::ScrollBar *result = 0 ;
68184
68185   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68186   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
68187   if (!arg2) {
68188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68189     return 0;
68190   }
68191   {
68192     try {
68193       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
68194     } catch (std::out_of_range& e) {
68195       {
68196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68197       };
68198     } catch (std::exception& e) {
68199       {
68200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68201       };
68202     } catch (Dali::DaliException e) {
68203       {
68204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68205       };
68206     } catch (...) {
68207       {
68208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68209       };
68210     }
68211   }
68212
68213   jresult = (void *)result;
68214   return jresult;
68215 }
68216
68217
68218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
68219   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68220
68221   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68222   {
68223     try {
68224       delete arg1;
68225     } catch (std::out_of_range& e) {
68226       {
68227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68228       };
68229     } catch (std::exception& e) {
68230       {
68231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68232       };
68233     } catch (Dali::DaliException e) {
68234       {
68235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68236       };
68237     } catch (...) {
68238       {
68239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68240       };
68241     }
68242   }
68243
68244 }
68245
68246
68247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
68248   void * jresult ;
68249   Dali::Toolkit::ScrollBar::Direction arg1 ;
68250   Dali::Toolkit::ScrollBar result;
68251
68252   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
68253   {
68254     try {
68255       result = Dali::Toolkit::ScrollBar::New(arg1);
68256     } catch (std::out_of_range& e) {
68257       {
68258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68259       };
68260     } catch (std::exception& e) {
68261       {
68262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68263       };
68264     } catch (Dali::DaliException e) {
68265       {
68266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68267       };
68268     } catch (...) {
68269       {
68270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68271       };
68272     }
68273   }
68274
68275   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68276   return jresult;
68277 }
68278
68279
68280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
68281   void * jresult ;
68282   Dali::Toolkit::ScrollBar result;
68283
68284   {
68285     try {
68286       result = Dali::Toolkit::ScrollBar::New();
68287     } catch (std::out_of_range& e) {
68288       {
68289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68290       };
68291     } catch (std::exception& e) {
68292       {
68293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68294       };
68295     } catch (Dali::DaliException e) {
68296       {
68297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68298       };
68299     } catch (...) {
68300       {
68301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68302       };
68303     }
68304   }
68305
68306   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68307   return jresult;
68308 }
68309
68310
68311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
68312   void * jresult ;
68313   Dali::BaseHandle arg1 ;
68314   Dali::BaseHandle *argp1 ;
68315   Dali::Toolkit::ScrollBar result;
68316
68317   argp1 = (Dali::BaseHandle *)jarg1;
68318   if (!argp1) {
68319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68320     return 0;
68321   }
68322   arg1 = *argp1;
68323   {
68324     try {
68325       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
68326     } catch (std::out_of_range& e) {
68327       {
68328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68329       };
68330     } catch (std::exception& e) {
68331       {
68332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68333       };
68334     } catch (Dali::DaliException e) {
68335       {
68336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68337       };
68338     } catch (...) {
68339       {
68340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68341       };
68342     }
68343   }
68344
68345   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68346   return jresult;
68347 }
68348
68349
68350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68351   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68352   Dali::Handle arg2 ;
68353   Dali::Property::Index arg3 ;
68354   Dali::Property::Index arg4 ;
68355   Dali::Property::Index arg5 ;
68356   Dali::Property::Index arg6 ;
68357   Dali::Handle *argp2 ;
68358
68359   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68360   argp2 = (Dali::Handle *)jarg2;
68361   if (!argp2) {
68362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68363     return ;
68364   }
68365   arg2 = *argp2;
68366   arg3 = (Dali::Property::Index)jarg3;
68367   arg4 = (Dali::Property::Index)jarg4;
68368   arg5 = (Dali::Property::Index)jarg5;
68369   arg6 = (Dali::Property::Index)jarg6;
68370   {
68371     try {
68372       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68373     } catch (std::out_of_range& e) {
68374       {
68375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68376       };
68377     } catch (std::exception& e) {
68378       {
68379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68380       };
68381     } catch (Dali::DaliException e) {
68382       {
68383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68384       };
68385     } catch (...) {
68386       {
68387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68388       };
68389     }
68390   }
68391
68392 }
68393
68394
68395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68396   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68397   Dali::Actor arg2 ;
68398   Dali::Actor *argp2 ;
68399
68400   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68401   argp2 = (Dali::Actor *)jarg2;
68402   if (!argp2) {
68403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68404     return ;
68405   }
68406   arg2 = *argp2;
68407   {
68408     try {
68409       (arg1)->SetScrollIndicator(arg2);
68410     } catch (std::out_of_range& e) {
68411       {
68412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68413       };
68414     } catch (std::exception& e) {
68415       {
68416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68417       };
68418     } catch (Dali::DaliException e) {
68419       {
68420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68421       };
68422     } catch (...) {
68423       {
68424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68425       };
68426     }
68427   }
68428
68429 }
68430
68431
68432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68433   void * jresult ;
68434   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68435   Dali::Actor result;
68436
68437   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68438   {
68439     try {
68440       result = (arg1)->GetScrollIndicator();
68441     } catch (std::out_of_range& e) {
68442       {
68443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68444       };
68445     } catch (std::exception& e) {
68446       {
68447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68448       };
68449     } catch (Dali::DaliException e) {
68450       {
68451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68452       };
68453     } catch (...) {
68454       {
68455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68456       };
68457     }
68458   }
68459
68460   jresult = new Dali::Actor((const Dali::Actor &)result);
68461   return jresult;
68462 }
68463
68464
68465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68466   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68467   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68468
68469   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68470   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68471   if (!arg2) {
68472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68473     return ;
68474   }
68475   {
68476     try {
68477       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68478     } catch (std::out_of_range& e) {
68479       {
68480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68481       };
68482     } catch (std::exception& e) {
68483       {
68484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68485       };
68486     } catch (Dali::DaliException e) {
68487       {
68488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68489       };
68490     } catch (...) {
68491       {
68492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68493       };
68494     }
68495   }
68496
68497 }
68498
68499
68500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68501   void * jresult ;
68502   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68503
68504   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68505   {
68506     try {
68507       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()));
68508     } catch (std::out_of_range& e) {
68509       {
68510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68511       };
68512     } catch (std::exception& e) {
68513       {
68514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68515       };
68516     } catch (...) {
68517       {
68518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68519       };
68520     }
68521   }
68522   return jresult;
68523 }
68524
68525
68526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68527   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68528   Dali::Toolkit::ScrollBar::Direction arg2 ;
68529
68530   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68531   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68532   {
68533     try {
68534       (arg1)->SetScrollDirection(arg2);
68535     } catch (std::out_of_range& e) {
68536       {
68537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68538       };
68539     } catch (std::exception& e) {
68540       {
68541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68542       };
68543     } catch (Dali::DaliException e) {
68544       {
68545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68546       };
68547     } catch (...) {
68548       {
68549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68550       };
68551     }
68552   }
68553
68554 }
68555
68556
68557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68558   int jresult ;
68559   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68560   Dali::Toolkit::ScrollBar::Direction result;
68561
68562   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68563   {
68564     try {
68565       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68566     } catch (std::out_of_range& e) {
68567       {
68568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68569       };
68570     } catch (std::exception& e) {
68571       {
68572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68573       };
68574     } catch (Dali::DaliException e) {
68575       {
68576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68577       };
68578     } catch (...) {
68579       {
68580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68581       };
68582     }
68583   }
68584
68585   jresult = (int)result;
68586   return jresult;
68587 }
68588
68589
68590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68591   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68592   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68593
68594   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68595   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68596   {
68597     try {
68598       (arg1)->SetIndicatorHeightPolicy(arg2);
68599     } catch (std::out_of_range& e) {
68600       {
68601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68602       };
68603     } catch (std::exception& e) {
68604       {
68605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68606       };
68607     } catch (Dali::DaliException e) {
68608       {
68609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68610       };
68611     } catch (...) {
68612       {
68613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68614       };
68615     }
68616   }
68617
68618 }
68619
68620
68621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68622   int jresult ;
68623   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68624   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68625
68626   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68627   {
68628     try {
68629       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68630     } catch (std::out_of_range& e) {
68631       {
68632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68633       };
68634     } catch (std::exception& e) {
68635       {
68636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68637       };
68638     } catch (Dali::DaliException e) {
68639       {
68640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68641       };
68642     } catch (...) {
68643       {
68644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68645       };
68646     }
68647   }
68648
68649   jresult = (int)result;
68650   return jresult;
68651 }
68652
68653
68654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68655   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68656   float arg2 ;
68657
68658   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68659   arg2 = (float)jarg2;
68660   {
68661     try {
68662       (arg1)->SetIndicatorFixedHeight(arg2);
68663     } catch (std::out_of_range& e) {
68664       {
68665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68666       };
68667     } catch (std::exception& e) {
68668       {
68669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68670       };
68671     } catch (Dali::DaliException e) {
68672       {
68673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68674       };
68675     } catch (...) {
68676       {
68677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68678       };
68679     }
68680   }
68681
68682 }
68683
68684
68685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68686   float jresult ;
68687   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68688   float result;
68689
68690   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68691   {
68692     try {
68693       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68694     } catch (std::out_of_range& e) {
68695       {
68696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68697       };
68698     } catch (std::exception& e) {
68699       {
68700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68701       };
68702     } catch (Dali::DaliException e) {
68703       {
68704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68705       };
68706     } catch (...) {
68707       {
68708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68709       };
68710     }
68711   }
68712
68713   jresult = result;
68714   return jresult;
68715 }
68716
68717
68718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68719   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68720   float arg2 ;
68721
68722   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68723   arg2 = (float)jarg2;
68724   {
68725     try {
68726       (arg1)->SetIndicatorShowDuration(arg2);
68727     } catch (std::out_of_range& e) {
68728       {
68729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68730       };
68731     } catch (std::exception& e) {
68732       {
68733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68734       };
68735     } catch (Dali::DaliException e) {
68736       {
68737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68738       };
68739     } catch (...) {
68740       {
68741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68742       };
68743     }
68744   }
68745
68746 }
68747
68748
68749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68750   float jresult ;
68751   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68752   float result;
68753
68754   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68755   {
68756     try {
68757       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68758     } catch (std::out_of_range& e) {
68759       {
68760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68761       };
68762     } catch (std::exception& e) {
68763       {
68764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68765       };
68766     } catch (Dali::DaliException e) {
68767       {
68768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68769       };
68770     } catch (...) {
68771       {
68772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68773       };
68774     }
68775   }
68776
68777   jresult = result;
68778   return jresult;
68779 }
68780
68781
68782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68783   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68784   float arg2 ;
68785
68786   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68787   arg2 = (float)jarg2;
68788   {
68789     try {
68790       (arg1)->SetIndicatorHideDuration(arg2);
68791     } catch (std::out_of_range& e) {
68792       {
68793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68794       };
68795     } catch (std::exception& e) {
68796       {
68797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68798       };
68799     } catch (Dali::DaliException e) {
68800       {
68801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68802       };
68803     } catch (...) {
68804       {
68805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68806       };
68807     }
68808   }
68809
68810 }
68811
68812
68813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68814   float jresult ;
68815   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68816   float result;
68817
68818   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68819   {
68820     try {
68821       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68822     } catch (std::out_of_range& e) {
68823       {
68824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68825       };
68826     } catch (std::exception& e) {
68827       {
68828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68829       };
68830     } catch (Dali::DaliException e) {
68831       {
68832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68833       };
68834     } catch (...) {
68835       {
68836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68837       };
68838     }
68839   }
68840
68841   jresult = result;
68842   return jresult;
68843 }
68844
68845
68846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68847   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68848
68849   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68850   {
68851     try {
68852       (arg1)->ShowIndicator();
68853     } catch (std::out_of_range& e) {
68854       {
68855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68856       };
68857     } catch (std::exception& e) {
68858       {
68859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68860       };
68861     } catch (Dali::DaliException e) {
68862       {
68863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68864       };
68865     } catch (...) {
68866       {
68867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68868       };
68869     }
68870   }
68871
68872 }
68873
68874
68875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68876   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68877
68878   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68879   {
68880     try {
68881       (arg1)->HideIndicator();
68882     } catch (std::out_of_range& e) {
68883       {
68884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68885       };
68886     } catch (std::exception& e) {
68887       {
68888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68889       };
68890     } catch (Dali::DaliException e) {
68891       {
68892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68893       };
68894     } catch (...) {
68895       {
68896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68897       };
68898     }
68899   }
68900
68901 }
68902
68903
68904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68905   void * jresult ;
68906   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68907   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68908
68909   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68910   {
68911     try {
68912       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68913     } catch (std::out_of_range& e) {
68914       {
68915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68916       };
68917     } catch (std::exception& e) {
68918       {
68919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68920       };
68921     } catch (Dali::DaliException e) {
68922       {
68923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68924       };
68925     } catch (...) {
68926       {
68927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68928       };
68929     }
68930   }
68931
68932   jresult = (void *)result;
68933   return jresult;
68934 }
68935
68936
68937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68938   void * jresult ;
68939   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68940   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68941
68942   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68943   {
68944     try {
68945       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68946     } catch (std::out_of_range& e) {
68947       {
68948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68949       };
68950     } catch (std::exception& e) {
68951       {
68952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68953       };
68954     } catch (Dali::DaliException e) {
68955       {
68956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68957       };
68958     } catch (...) {
68959       {
68960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68961       };
68962     }
68963   }
68964
68965   jresult = (void *)result;
68966   return jresult;
68967 }
68968
68969
68970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68971   int jresult ;
68972   int result;
68973
68974   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68975   jresult = (int)result;
68976   return jresult;
68977 }
68978
68979
68980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68981   int jresult ;
68982   int result;
68983
68984   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68985   jresult = (int)result;
68986   return jresult;
68987 }
68988
68989
68990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68991   int jresult ;
68992   int result;
68993
68994   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68995   jresult = (int)result;
68996   return jresult;
68997 }
68998
68999
69000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
69001   int jresult ;
69002   int result;
69003
69004   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
69005   jresult = (int)result;
69006   return jresult;
69007 }
69008
69009
69010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
69011   int jresult ;
69012   int result;
69013
69014   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
69015   jresult = (int)result;
69016   return jresult;
69017 }
69018
69019
69020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
69021   int jresult ;
69022   int result;
69023
69024   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
69025   jresult = (int)result;
69026   return jresult;
69027 }
69028
69029
69030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
69031   int jresult ;
69032   int result;
69033
69034   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
69035   jresult = (int)result;
69036   return jresult;
69037 }
69038
69039
69040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
69041   int jresult ;
69042   int result;
69043
69044   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
69045   jresult = (int)result;
69046   return jresult;
69047 }
69048
69049
69050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
69051   int jresult ;
69052   int result;
69053
69054   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
69055   jresult = (int)result;
69056   return jresult;
69057 }
69058
69059
69060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
69061   int jresult ;
69062   int result;
69063
69064   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
69065   jresult = (int)result;
69066   return jresult;
69067 }
69068
69069
69070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
69071   int jresult ;
69072   int result;
69073
69074   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
69075   jresult = (int)result;
69076   return jresult;
69077 }
69078
69079
69080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
69081   int jresult ;
69082   int result;
69083
69084   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
69085   jresult = (int)result;
69086   return jresult;
69087 }
69088
69089
69090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
69091   int jresult ;
69092   int result;
69093
69094   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
69095   jresult = (int)result;
69096   return jresult;
69097 }
69098
69099
69100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
69101   int jresult ;
69102   int result;
69103
69104   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
69105   jresult = (int)result;
69106   return jresult;
69107 }
69108
69109
69110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
69111   void * jresult ;
69112   Dali::Toolkit::Scrollable::Property *result = 0 ;
69113
69114   {
69115     try {
69116       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
69117     } catch (std::out_of_range& e) {
69118       {
69119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69120       };
69121     } catch (std::exception& e) {
69122       {
69123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69124       };
69125     } catch (Dali::DaliException e) {
69126       {
69127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69128       };
69129     } catch (...) {
69130       {
69131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69132       };
69133     }
69134   }
69135
69136   jresult = (void *)result;
69137   return jresult;
69138 }
69139
69140
69141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
69142   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
69143
69144   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
69145   {
69146     try {
69147       delete arg1;
69148     } catch (std::out_of_range& e) {
69149       {
69150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69151       };
69152     } catch (std::exception& e) {
69153       {
69154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69155       };
69156     } catch (Dali::DaliException e) {
69157       {
69158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69159       };
69160     } catch (...) {
69161       {
69162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69163       };
69164     }
69165   }
69166
69167 }
69168
69169
69170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
69171   void * jresult ;
69172   Dali::Toolkit::Scrollable *result = 0 ;
69173
69174   {
69175     try {
69176       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
69177     } catch (std::out_of_range& e) {
69178       {
69179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69180       };
69181     } catch (std::exception& e) {
69182       {
69183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69184       };
69185     } catch (Dali::DaliException e) {
69186       {
69187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69188       };
69189     } catch (...) {
69190       {
69191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69192       };
69193     }
69194   }
69195
69196   jresult = (void *)result;
69197   return jresult;
69198 }
69199
69200
69201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
69202   void * jresult ;
69203   Dali::Toolkit::Scrollable *arg1 = 0 ;
69204   Dali::Toolkit::Scrollable *result = 0 ;
69205
69206   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69207   if (!arg1) {
69208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69209     return 0;
69210   }
69211   {
69212     try {
69213       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
69214     } catch (std::out_of_range& e) {
69215       {
69216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69217       };
69218     } catch (std::exception& e) {
69219       {
69220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69221       };
69222     } catch (Dali::DaliException e) {
69223       {
69224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69225       };
69226     } catch (...) {
69227       {
69228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69229       };
69230     }
69231   }
69232
69233   jresult = (void *)result;
69234   return jresult;
69235 }
69236
69237
69238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
69239   void * jresult ;
69240   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69241   Dali::Toolkit::Scrollable *arg2 = 0 ;
69242   Dali::Toolkit::Scrollable *result = 0 ;
69243
69244   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69245   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
69246   if (!arg2) {
69247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69248     return 0;
69249   }
69250   {
69251     try {
69252       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
69253     } catch (std::out_of_range& e) {
69254       {
69255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69256       };
69257     } catch (std::exception& e) {
69258       {
69259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69260       };
69261     } catch (Dali::DaliException e) {
69262       {
69263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69264       };
69265     } catch (...) {
69266       {
69267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69268       };
69269     }
69270   }
69271
69272   jresult = (void *)result;
69273   return jresult;
69274 }
69275
69276
69277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
69278   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69279
69280   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69281   {
69282     try {
69283       delete arg1;
69284     } catch (std::out_of_range& e) {
69285       {
69286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69287       };
69288     } catch (std::exception& e) {
69289       {
69290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69291       };
69292     } catch (Dali::DaliException e) {
69293       {
69294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69295       };
69296     } catch (...) {
69297       {
69298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69299       };
69300     }
69301   }
69302
69303 }
69304
69305
69306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
69307   void * jresult ;
69308   Dali::BaseHandle arg1 ;
69309   Dali::BaseHandle *argp1 ;
69310   Dali::Toolkit::Scrollable result;
69311
69312   argp1 = (Dali::BaseHandle *)jarg1;
69313   if (!argp1) {
69314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69315     return 0;
69316   }
69317   arg1 = *argp1;
69318   {
69319     try {
69320       result = Dali::Toolkit::Scrollable::DownCast(arg1);
69321     } catch (std::out_of_range& e) {
69322       {
69323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69324       };
69325     } catch (std::exception& e) {
69326       {
69327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69328       };
69329     } catch (Dali::DaliException e) {
69330       {
69331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69332       };
69333     } catch (...) {
69334       {
69335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69336       };
69337     }
69338   }
69339
69340   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
69341   return jresult;
69342 }
69343
69344
69345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
69346   unsigned int jresult ;
69347   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69348   bool result;
69349
69350   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69351   {
69352     try {
69353       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
69354     } catch (std::out_of_range& e) {
69355       {
69356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69357       };
69358     } catch (std::exception& e) {
69359       {
69360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69361       };
69362     } catch (Dali::DaliException e) {
69363       {
69364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69365       };
69366     } catch (...) {
69367       {
69368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69369       };
69370     }
69371   }
69372
69373   jresult = result;
69374   return jresult;
69375 }
69376
69377
69378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
69379   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69380   bool arg2 ;
69381
69382   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69383   arg2 = jarg2 ? true : false;
69384   {
69385     try {
69386       (arg1)->SetOvershootEnabled(arg2);
69387     } catch (std::out_of_range& e) {
69388       {
69389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69390       };
69391     } catch (std::exception& e) {
69392       {
69393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69394       };
69395     } catch (Dali::DaliException e) {
69396       {
69397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69398       };
69399     } catch (...) {
69400       {
69401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69402       };
69403     }
69404   }
69405
69406 }
69407
69408
69409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69410   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69411   Dali::Vector4 *arg2 = 0 ;
69412
69413   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69414   arg2 = (Dali::Vector4 *)jarg2;
69415   if (!arg2) {
69416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69417     return ;
69418   }
69419   {
69420     try {
69421       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69422     } catch (std::out_of_range& e) {
69423       {
69424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69425       };
69426     } catch (std::exception& e) {
69427       {
69428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69429       };
69430     } catch (Dali::DaliException e) {
69431       {
69432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69433       };
69434     } catch (...) {
69435       {
69436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69437       };
69438     }
69439   }
69440
69441 }
69442
69443
69444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69445   void * jresult ;
69446   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69447   Dali::Vector4 result;
69448
69449   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69450   {
69451     try {
69452       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69453     } catch (std::out_of_range& e) {
69454       {
69455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69456       };
69457     } catch (std::exception& e) {
69458       {
69459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69460       };
69461     } catch (Dali::DaliException e) {
69462       {
69463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69464       };
69465     } catch (...) {
69466       {
69467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69468       };
69469     }
69470   }
69471
69472   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69473   return jresult;
69474 }
69475
69476
69477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69478   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69479   float arg2 ;
69480
69481   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69482   arg2 = (float)jarg2;
69483   {
69484     try {
69485       (arg1)->SetOvershootAnimationSpeed(arg2);
69486     } catch (std::out_of_range& e) {
69487       {
69488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69489       };
69490     } catch (std::exception& e) {
69491       {
69492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69493       };
69494     } catch (Dali::DaliException e) {
69495       {
69496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69497       };
69498     } catch (...) {
69499       {
69500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69501       };
69502     }
69503   }
69504
69505 }
69506
69507
69508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69509   float jresult ;
69510   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69511   float result;
69512
69513   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69514   {
69515     try {
69516       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69517     } catch (std::out_of_range& e) {
69518       {
69519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69520       };
69521     } catch (std::exception& e) {
69522       {
69523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69524       };
69525     } catch (Dali::DaliException e) {
69526       {
69527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69528       };
69529     } catch (...) {
69530       {
69531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69532       };
69533     }
69534   }
69535
69536   jresult = result;
69537   return jresult;
69538 }
69539
69540
69541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69542   void * jresult ;
69543   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69544   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69545
69546   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69547   {
69548     try {
69549       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69550     } catch (std::out_of_range& e) {
69551       {
69552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69553       };
69554     } catch (std::exception& e) {
69555       {
69556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69557       };
69558     } catch (Dali::DaliException e) {
69559       {
69560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69561       };
69562     } catch (...) {
69563       {
69564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69565       };
69566     }
69567   }
69568
69569   jresult = (void *)result;
69570   return jresult;
69571 }
69572
69573
69574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69575   void * jresult ;
69576   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69577   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69578
69579   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69580   {
69581     try {
69582       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69583     } catch (std::out_of_range& e) {
69584       {
69585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69586       };
69587     } catch (std::exception& e) {
69588       {
69589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69590       };
69591     } catch (Dali::DaliException e) {
69592       {
69593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69594       };
69595     } catch (...) {
69596       {
69597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69598       };
69599     }
69600   }
69601
69602   jresult = (void *)result;
69603   return jresult;
69604 }
69605
69606
69607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69608   void * jresult ;
69609   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69610   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69611
69612   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69613   {
69614     try {
69615       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69616     } catch (std::out_of_range& e) {
69617       {
69618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69619       };
69620     } catch (std::exception& e) {
69621       {
69622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69623       };
69624     } catch (Dali::DaliException e) {
69625       {
69626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69627       };
69628     } catch (...) {
69629       {
69630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69631       };
69632     }
69633   }
69634
69635   jresult = (void *)result;
69636   return jresult;
69637 }
69638
69639
69640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69641   unsigned int jresult ;
69642   Dali::Toolkit::ControlOrientation::Type arg1 ;
69643   bool result;
69644
69645   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69646   {
69647     try {
69648       result = (bool)Dali::Toolkit::IsVertical(arg1);
69649     } catch (std::out_of_range& e) {
69650       {
69651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69652       };
69653     } catch (std::exception& e) {
69654       {
69655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69656       };
69657     } catch (Dali::DaliException e) {
69658       {
69659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69660       };
69661     } catch (...) {
69662       {
69663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69664       };
69665     }
69666   }
69667
69668   jresult = result;
69669   return jresult;
69670 }
69671
69672
69673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69674   unsigned int jresult ;
69675   Dali::Toolkit::ControlOrientation::Type arg1 ;
69676   bool result;
69677
69678   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69679   {
69680     try {
69681       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69682     } catch (std::out_of_range& e) {
69683       {
69684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69685       };
69686     } catch (std::exception& e) {
69687       {
69688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69689       };
69690     } catch (Dali::DaliException e) {
69691       {
69692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69693       };
69694     } catch (...) {
69695       {
69696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69697       };
69698     }
69699   }
69700
69701   jresult = result;
69702   return jresult;
69703 }
69704
69705
69706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69707   void * jresult ;
69708   unsigned int arg1 ;
69709   unsigned int arg2 ;
69710   Dali::Toolkit::ItemRange *result = 0 ;
69711
69712   arg1 = (unsigned int)jarg1;
69713   arg2 = (unsigned int)jarg2;
69714   {
69715     try {
69716       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69717     } catch (std::out_of_range& e) {
69718       {
69719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69720       };
69721     } catch (std::exception& e) {
69722       {
69723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69724       };
69725     } catch (Dali::DaliException e) {
69726       {
69727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69728       };
69729     } catch (...) {
69730       {
69731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69732       };
69733     }
69734   }
69735
69736   jresult = (void *)result;
69737   return jresult;
69738 }
69739
69740
69741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69742   void * jresult ;
69743   Dali::Toolkit::ItemRange *arg1 = 0 ;
69744   Dali::Toolkit::ItemRange *result = 0 ;
69745
69746   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69747   if (!arg1) {
69748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69749     return 0;
69750   }
69751   {
69752     try {
69753       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69754     } catch (std::out_of_range& e) {
69755       {
69756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69757       };
69758     } catch (std::exception& e) {
69759       {
69760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69761       };
69762     } catch (Dali::DaliException e) {
69763       {
69764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69765       };
69766     } catch (...) {
69767       {
69768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69769       };
69770     }
69771   }
69772
69773   jresult = (void *)result;
69774   return jresult;
69775 }
69776
69777
69778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69779   void * jresult ;
69780   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69781   Dali::Toolkit::ItemRange *arg2 = 0 ;
69782   Dali::Toolkit::ItemRange *result = 0 ;
69783
69784   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69785   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69786   if (!arg2) {
69787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69788     return 0;
69789   }
69790   {
69791     try {
69792       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69793     } catch (std::out_of_range& e) {
69794       {
69795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69796       };
69797     } catch (std::exception& e) {
69798       {
69799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69800       };
69801     } catch (Dali::DaliException e) {
69802       {
69803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69804       };
69805     } catch (...) {
69806       {
69807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69808       };
69809     }
69810   }
69811
69812   jresult = (void *)result;
69813   return jresult;
69814 }
69815
69816
69817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69818   unsigned int jresult ;
69819   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69820   unsigned int arg2 ;
69821   bool result;
69822
69823   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69824   arg2 = (unsigned int)jarg2;
69825   {
69826     try {
69827       result = (bool)(arg1)->Within(arg2);
69828     } catch (std::out_of_range& e) {
69829       {
69830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69831       };
69832     } catch (std::exception& e) {
69833       {
69834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69835       };
69836     } catch (Dali::DaliException e) {
69837       {
69838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69839       };
69840     } catch (...) {
69841       {
69842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69843       };
69844     }
69845   }
69846
69847   jresult = result;
69848   return jresult;
69849 }
69850
69851
69852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69853   void * jresult ;
69854   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69855   Dali::Toolkit::ItemRange *arg2 = 0 ;
69856   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69857
69858   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69859   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69860   if (!arg2) {
69861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69862     return 0;
69863   }
69864   {
69865     try {
69866       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69867     } catch (std::out_of_range& e) {
69868       {
69869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69870       };
69871     } catch (std::exception& e) {
69872       {
69873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69874       };
69875     } catch (Dali::DaliException e) {
69876       {
69877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69878       };
69879     } catch (...) {
69880       {
69881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69882       };
69883     }
69884   }
69885
69886   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69887   return jresult;
69888 }
69889
69890
69891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69892   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69893   unsigned int arg2 ;
69894
69895   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69896   arg2 = (unsigned int)jarg2;
69897   if (arg1) (arg1)->begin = arg2;
69898 }
69899
69900
69901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69902   unsigned int jresult ;
69903   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69904   unsigned int result;
69905
69906   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69907   result = (unsigned int) ((arg1)->begin);
69908   jresult = result;
69909   return jresult;
69910 }
69911
69912
69913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69914   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69915   unsigned int arg2 ;
69916
69917   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69918   arg2 = (unsigned int)jarg2;
69919   if (arg1) (arg1)->end = arg2;
69920 }
69921
69922
69923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69924   unsigned int jresult ;
69925   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69926   unsigned int result;
69927
69928   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69929   result = (unsigned int) ((arg1)->end);
69930   jresult = result;
69931   return jresult;
69932 }
69933
69934
69935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69936   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69937
69938   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69939   {
69940     try {
69941       delete arg1;
69942     } catch (std::out_of_range& e) {
69943       {
69944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69945       };
69946     } catch (std::exception& e) {
69947       {
69948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69949       };
69950     } catch (Dali::DaliException e) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69953       };
69954     } catch (...) {
69955       {
69956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69957       };
69958     }
69959   }
69960
69961 }
69962
69963
69964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69965   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69966
69967   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69968   {
69969     try {
69970       delete arg1;
69971     } catch (std::out_of_range& e) {
69972       {
69973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69974       };
69975     } catch (std::exception& e) {
69976       {
69977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69978       };
69979     } catch (Dali::DaliException e) {
69980       {
69981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69982       };
69983     } catch (...) {
69984       {
69985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69986       };
69987     }
69988   }
69989
69990 }
69991
69992
69993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69994   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69995   Dali::Toolkit::ControlOrientation::Type arg2 ;
69996
69997   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69998   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69999   {
70000     try {
70001       (arg1)->SetOrientation(arg2);
70002     } catch (std::out_of_range& e) {
70003       {
70004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70005       };
70006     } catch (std::exception& e) {
70007       {
70008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70009       };
70010     } catch (Dali::DaliException e) {
70011       {
70012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70013       };
70014     } catch (...) {
70015       {
70016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70017       };
70018     }
70019   }
70020
70021 }
70022
70023
70024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
70025   int jresult ;
70026   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70027   Dali::Toolkit::ControlOrientation::Type result;
70028
70029   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70030   {
70031     try {
70032       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
70033     } catch (std::out_of_range& e) {
70034       {
70035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70036       };
70037     } catch (std::exception& e) {
70038       {
70039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70040       };
70041     } catch (Dali::DaliException e) {
70042       {
70043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70044       };
70045     } catch (...) {
70046       {
70047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70048       };
70049     }
70050   }
70051
70052   jresult = (int)result;
70053   return jresult;
70054 }
70055
70056
70057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
70058   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70059   Dali::Property::Map *arg2 = 0 ;
70060
70061   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70062   arg2 = (Dali::Property::Map *)jarg2;
70063   if (!arg2) {
70064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
70065     return ;
70066   }
70067   {
70068     try {
70069       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
70070     } catch (std::out_of_range& e) {
70071       {
70072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70073       };
70074     } catch (std::exception& e) {
70075       {
70076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70077       };
70078     } catch (Dali::DaliException e) {
70079       {
70080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70081       };
70082     } catch (...) {
70083       {
70084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70085       };
70086     }
70087   }
70088
70089 }
70090
70091
70092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
70093   void * jresult ;
70094   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70095   Dali::Property::Map result;
70096
70097   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70098   {
70099     try {
70100       result = (arg1)->GetLayoutProperties();
70101     } catch (std::out_of_range& e) {
70102       {
70103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70104       };
70105     } catch (std::exception& e) {
70106       {
70107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70108       };
70109     } catch (Dali::DaliException e) {
70110       {
70111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70112       };
70113     } catch (...) {
70114       {
70115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70116       };
70117     }
70118   }
70119
70120   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
70121   return jresult;
70122 }
70123
70124
70125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70126   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70127   unsigned int arg2 ;
70128   Dali::Vector3 *arg3 = 0 ;
70129   Dali::Vector3 *arg4 = 0 ;
70130
70131   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70132   arg2 = (unsigned int)jarg2;
70133   arg3 = (Dali::Vector3 *)jarg3;
70134   if (!arg3) {
70135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70136     return ;
70137   }
70138   arg4 = (Dali::Vector3 *)jarg4;
70139   if (!arg4) {
70140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70141     return ;
70142   }
70143   {
70144     try {
70145       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70146     } catch (std::out_of_range& e) {
70147       {
70148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70149       };
70150     } catch (std::exception& e) {
70151       {
70152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70153       };
70154     } catch (Dali::DaliException e) {
70155       {
70156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70157       };
70158     } catch (...) {
70159       {
70160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70161       };
70162     }
70163   }
70164
70165 }
70166
70167
70168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
70169   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70170   Dali::Vector3 *arg2 = 0 ;
70171
70172   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70173   arg2 = (Dali::Vector3 *)jarg2;
70174   if (!arg2) {
70175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70176     return ;
70177   }
70178   {
70179     try {
70180       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
70181     } catch (std::out_of_range& e) {
70182       {
70183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70184       };
70185     } catch (std::exception& e) {
70186       {
70187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70188       };
70189     } catch (Dali::DaliException e) {
70190       {
70191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70192       };
70193     } catch (...) {
70194       {
70195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70196       };
70197     }
70198   }
70199
70200 }
70201
70202
70203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
70204   float jresult ;
70205   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70206   unsigned int arg2 ;
70207   Dali::Vector3 arg3 ;
70208   Dali::Vector3 *argp3 ;
70209   float result;
70210
70211   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70212   arg2 = (unsigned int)jarg2;
70213   argp3 = (Dali::Vector3 *)jarg3;
70214   if (!argp3) {
70215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70216     return 0;
70217   }
70218   arg3 = *argp3;
70219   {
70220     try {
70221       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
70222     } catch (std::out_of_range& e) {
70223       {
70224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70225       };
70226     } catch (std::exception& e) {
70227       {
70228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70229       };
70230     } catch (Dali::DaliException e) {
70231       {
70232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70233       };
70234     } catch (...) {
70235       {
70236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70237       };
70238     }
70239   }
70240
70241   jresult = result;
70242   return jresult;
70243 }
70244
70245
70246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
70247   float jresult ;
70248   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70249   float arg2 ;
70250   float result;
70251
70252   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70253   arg2 = (float)jarg2;
70254   {
70255     try {
70256       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
70257     } catch (std::out_of_range& e) {
70258       {
70259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70260       };
70261     } catch (std::exception& e) {
70262       {
70263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70264       };
70265     } catch (Dali::DaliException e) {
70266       {
70267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70268       };
70269     } catch (...) {
70270       {
70271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70272       };
70273     }
70274   }
70275
70276   jresult = result;
70277   return jresult;
70278 }
70279
70280
70281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
70282   float jresult ;
70283   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70284   unsigned int arg2 ;
70285   float result;
70286
70287   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70288   arg2 = (unsigned int)jarg2;
70289   {
70290     try {
70291       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
70292     } catch (std::out_of_range& e) {
70293       {
70294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70295       };
70296     } catch (std::exception& e) {
70297       {
70298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70299       };
70300     } catch (Dali::DaliException e) {
70301       {
70302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70303       };
70304     } catch (...) {
70305       {
70306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70307       };
70308     }
70309   }
70310
70311   jresult = result;
70312   return jresult;
70313 }
70314
70315
70316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
70317   void * jresult ;
70318   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70319   float arg2 ;
70320   Dali::Vector3 arg3 ;
70321   Dali::Vector3 *argp3 ;
70322   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
70323
70324   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70325   arg2 = (float)jarg2;
70326   argp3 = (Dali::Vector3 *)jarg3;
70327   if (!argp3) {
70328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70329     return 0;
70330   }
70331   arg3 = *argp3;
70332   {
70333     try {
70334       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
70335     } catch (std::out_of_range& e) {
70336       {
70337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70338       };
70339     } catch (std::exception& e) {
70340       {
70341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70342       };
70343     } catch (Dali::DaliException e) {
70344       {
70345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70346       };
70347     } catch (...) {
70348       {
70349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70350       };
70351     }
70352   }
70353
70354   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
70355   return jresult;
70356 }
70357
70358
70359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70360   float jresult ;
70361   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70362   int arg2 ;
70363   float arg3 ;
70364   Dali::Vector3 *arg4 = 0 ;
70365   float result;
70366
70367   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70368   arg2 = (int)jarg2;
70369   arg3 = (float)jarg3;
70370   arg4 = (Dali::Vector3 *)jarg4;
70371   if (!arg4) {
70372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70373     return 0;
70374   }
70375   {
70376     try {
70377       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70378     } catch (std::out_of_range& e) {
70379       {
70380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70381       };
70382     } catch (std::exception& e) {
70383       {
70384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70385       };
70386     } catch (Dali::DaliException e) {
70387       {
70388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70389       };
70390     } catch (...) {
70391       {
70392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70393       };
70394     }
70395   }
70396
70397   jresult = result;
70398   return jresult;
70399 }
70400
70401
70402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
70403   unsigned int jresult ;
70404   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70405   Dali::Vector3 arg2 ;
70406   Dali::Vector3 *argp2 ;
70407   unsigned int result;
70408
70409   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70410   argp2 = (Dali::Vector3 *)jarg2;
70411   if (!argp2) {
70412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70413     return 0;
70414   }
70415   arg2 = *argp2;
70416   {
70417     try {
70418       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70419     } catch (std::out_of_range& e) {
70420       {
70421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70422       };
70423     } catch (std::exception& e) {
70424       {
70425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70426       };
70427     } catch (Dali::DaliException e) {
70428       {
70429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70430       };
70431     } catch (...) {
70432       {
70433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70434       };
70435     }
70436   }
70437
70438   jresult = result;
70439   return jresult;
70440 }
70441
70442
70443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70444   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70445   unsigned int arg2 ;
70446   Dali::Vector3 *arg3 = 0 ;
70447   Dali::Vector3 *arg4 = 0 ;
70448
70449   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70450   arg2 = (unsigned int)jarg2;
70451   arg3 = (Dali::Vector3 *)jarg3;
70452   if (!arg3) {
70453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70454     return ;
70455   }
70456   arg4 = (Dali::Vector3 *)jarg4;
70457   if (!arg4) {
70458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70459     return ;
70460   }
70461   {
70462     try {
70463       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70464     } catch (std::out_of_range& e) {
70465       {
70466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70467       };
70468     } catch (std::exception& e) {
70469       {
70470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70471       };
70472     } catch (Dali::DaliException e) {
70473       {
70474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70475       };
70476     } catch (...) {
70477       {
70478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70479       };
70480     }
70481   }
70482
70483 }
70484
70485
70486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70487   void * jresult ;
70488   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70489   Dali::Degree result;
70490
70491   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70492   {
70493     try {
70494       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70495     } catch (std::out_of_range& e) {
70496       {
70497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70498       };
70499     } catch (std::exception& e) {
70500       {
70501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70502       };
70503     } catch (Dali::DaliException e) {
70504       {
70505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70506       };
70507     } catch (...) {
70508       {
70509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70510       };
70511     }
70512   }
70513
70514   jresult = new Dali::Degree((const Dali::Degree &)result);
70515   return jresult;
70516 }
70517
70518
70519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70520   float jresult ;
70521   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70522   float result;
70523
70524   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70525   {
70526     try {
70527       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70528     } catch (std::out_of_range& e) {
70529       {
70530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70531       };
70532     } catch (std::exception& e) {
70533       {
70534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70535       };
70536     } catch (Dali::DaliException e) {
70537       {
70538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70539       };
70540     } catch (...) {
70541       {
70542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70543       };
70544     }
70545   }
70546
70547   jresult = result;
70548   return jresult;
70549 }
70550
70551
70552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70553   float jresult ;
70554   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70555   float result;
70556
70557   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70558   {
70559     try {
70560       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70561     } catch (std::out_of_range& e) {
70562       {
70563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70564       };
70565     } catch (std::exception& e) {
70566       {
70567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70568       };
70569     } catch (Dali::DaliException e) {
70570       {
70571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70572       };
70573     } catch (...) {
70574       {
70575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70576       };
70577     }
70578   }
70579
70580   jresult = result;
70581   return jresult;
70582 }
70583
70584
70585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70586   float jresult ;
70587   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70588   float result;
70589
70590   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70591   {
70592     try {
70593       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70594     } catch (std::out_of_range& e) {
70595       {
70596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70597       };
70598     } catch (std::exception& e) {
70599       {
70600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70601       };
70602     } catch (Dali::DaliException e) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70605       };
70606     } catch (...) {
70607       {
70608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70609       };
70610     }
70611   }
70612
70613   jresult = result;
70614   return jresult;
70615 }
70616
70617
70618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70619   int jresult ;
70620   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70621   int arg2 ;
70622   int arg3 ;
70623   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70624   bool arg5 ;
70625   int result;
70626
70627   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70628   arg2 = (int)jarg2;
70629   arg3 = (int)jarg3;
70630   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70631   arg5 = jarg5 ? true : false;
70632   {
70633     try {
70634       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70635     } catch (std::out_of_range& e) {
70636       {
70637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70638       };
70639     } catch (std::exception& e) {
70640       {
70641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70642       };
70643     } catch (Dali::DaliException e) {
70644       {
70645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70646       };
70647     } catch (...) {
70648       {
70649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70650       };
70651     }
70652   }
70653
70654   jresult = result;
70655   return jresult;
70656 }
70657
70658
70659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70660   float jresult ;
70661   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70662   float result;
70663
70664   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70665   {
70666     try {
70667       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70668     } catch (std::out_of_range& e) {
70669       {
70670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70671       };
70672     } catch (std::exception& e) {
70673       {
70674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70675       };
70676     } catch (Dali::DaliException e) {
70677       {
70678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70679       };
70680     } catch (...) {
70681       {
70682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70683       };
70684     }
70685   }
70686
70687   jresult = result;
70688   return jresult;
70689 }
70690
70691
70692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70693   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70694   Dali::Actor *arg2 = 0 ;
70695   int arg3 ;
70696   Dali::Vector3 *arg4 = 0 ;
70697   Dali::Actor *arg5 = 0 ;
70698
70699   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70700   arg2 = (Dali::Actor *)jarg2;
70701   if (!arg2) {
70702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70703     return ;
70704   }
70705   arg3 = (int)jarg3;
70706   arg4 = (Dali::Vector3 *)jarg4;
70707   if (!arg4) {
70708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70709     return ;
70710   }
70711   arg5 = (Dali::Actor *)jarg5;
70712   if (!arg5) {
70713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70714     return ;
70715   }
70716   {
70717     try {
70718       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70719     } catch (std::out_of_range& e) {
70720       {
70721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70722       };
70723     } catch (std::exception& e) {
70724       {
70725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70726       };
70727     } catch (Dali::DaliException e) {
70728       {
70729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70730       };
70731     } catch (...) {
70732       {
70733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70734       };
70735     }
70736   }
70737
70738 }
70739
70740
70741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70742   void * jresult ;
70743   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70744   int arg2 ;
70745   float arg3 ;
70746   Dali::Vector3 *arg4 = 0 ;
70747   Dali::Vector3 result;
70748
70749   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70750   arg2 = (int)jarg2;
70751   arg3 = (float)jarg3;
70752   arg4 = (Dali::Vector3 *)jarg4;
70753   if (!arg4) {
70754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70755     return 0;
70756   }
70757   {
70758     try {
70759       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70760     } catch (std::out_of_range& e) {
70761       {
70762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70763       };
70764     } catch (std::exception& e) {
70765       {
70766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70767       };
70768     } catch (Dali::DaliException e) {
70769       {
70770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70771       };
70772     } catch (...) {
70773       {
70774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70775       };
70776     }
70777   }
70778
70779   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70780   return jresult;
70781 }
70782
70783
70784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70785   void * jresult ;
70786   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70787   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70788
70789   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70790   {
70791     try {
70792       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70793     } catch (std::out_of_range& e) {
70794       {
70795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70796       };
70797     } catch (std::exception& e) {
70798       {
70799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70800       };
70801     } catch (Dali::DaliException e) {
70802       {
70803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70804       };
70805     } catch (...) {
70806       {
70807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70808       };
70809     }
70810   }
70811
70812   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70813   return jresult;
70814 }
70815
70816
70817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70818   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70819
70820   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70821   {
70822     try {
70823       delete arg1;
70824     } catch (std::out_of_range& e) {
70825       {
70826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70827       };
70828     } catch (std::exception& e) {
70829       {
70830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70831       };
70832     } catch (Dali::DaliException e) {
70833       {
70834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70835       };
70836     } catch (...) {
70837       {
70838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70839       };
70840     }
70841   }
70842
70843 }
70844
70845
70846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70847   unsigned int jresult ;
70848   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70849   unsigned int result;
70850
70851   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70852   {
70853     try {
70854       result = (unsigned int)(arg1)->GetNumberOfItems();
70855     } catch (std::out_of_range& e) {
70856       {
70857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70858       };
70859     } catch (std::exception& e) {
70860       {
70861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70862       };
70863     } catch (Dali::DaliException e) {
70864       {
70865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70866       };
70867     } catch (...) {
70868       {
70869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70870       };
70871     }
70872   }
70873
70874   jresult = result;
70875   return jresult;
70876 }
70877
70878
70879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70880   void * jresult ;
70881   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70882   unsigned int arg2 ;
70883   Dali::Actor result;
70884
70885   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70886   arg2 = (unsigned int)jarg2;
70887   {
70888     try {
70889       result = (arg1)->NewItem(arg2);
70890     } catch (std::out_of_range& e) {
70891       {
70892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70893       };
70894     } catch (std::exception& e) {
70895       {
70896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70897       };
70898     } catch (Dali::DaliException e) {
70899       {
70900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70901       };
70902     } catch (...) {
70903       {
70904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70905       };
70906     }
70907   }
70908
70909   jresult = new Dali::Actor((const Dali::Actor &)result);
70910   return jresult;
70911 }
70912
70913
70914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70915   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70916   unsigned int arg2 ;
70917   Dali::Actor arg3 ;
70918   Dali::Actor *argp3 ;
70919
70920   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70921   arg2 = (unsigned int)jarg2;
70922   argp3 = (Dali::Actor *)jarg3;
70923   if (!argp3) {
70924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70925     return ;
70926   }
70927   arg3 = *argp3;
70928   {
70929     try {
70930       (arg1)->ItemReleased(arg2,arg3);
70931     } catch (std::out_of_range& e) {
70932       {
70933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70934       };
70935     } catch (std::exception& e) {
70936       {
70937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70938       };
70939     } catch (Dali::DaliException e) {
70940       {
70941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70942       };
70943     } catch (...) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70946       };
70947     }
70948   }
70949
70950 }
70951
70952
70953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70954   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70955   unsigned int arg2 ;
70956   Dali::Actor arg3 ;
70957   Dali::Actor *argp3 ;
70958
70959   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70960   arg2 = (unsigned int)jarg2;
70961   argp3 = (Dali::Actor *)jarg3;
70962   if (!argp3) {
70963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70964     return ;
70965   }
70966   arg3 = *argp3;
70967   {
70968     try {
70969       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70970     } catch (std::out_of_range& e) {
70971       {
70972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70973       };
70974     } catch (std::exception& e) {
70975       {
70976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70977       };
70978     } catch (Dali::DaliException e) {
70979       {
70980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70981       };
70982     } catch (...) {
70983       {
70984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70985       };
70986     }
70987   }
70988
70989 }
70990
70991
70992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70993   void * jresult ;
70994   Dali::Toolkit::ItemFactory *result = 0 ;
70995
70996   {
70997     try {
70998       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70999     } catch (std::out_of_range& e) {
71000       {
71001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71002       };
71003     } catch (std::exception& e) {
71004       {
71005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71006       };
71007     } catch (Dali::DaliException e) {
71008       {
71009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71010       };
71011     } catch (...) {
71012       {
71013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71014       };
71015     }
71016   }
71017
71018   jresult = (void *)result;
71019   return jresult;
71020 }
71021
71022
71023 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) {
71024   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
71025   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
71026   if (director) {
71027     director->swig_connect_director(callback0, callback1, callback2);
71028   }
71029 }
71030
71031
71032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
71033   int jresult ;
71034   int result;
71035
71036   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
71037   jresult = (int)result;
71038   return jresult;
71039 }
71040
71041
71042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
71043   int jresult ;
71044   int result;
71045
71046   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
71047   jresult = (int)result;
71048   return jresult;
71049 }
71050
71051
71052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
71053   int jresult ;
71054   int result;
71055
71056   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
71057   jresult = (int)result;
71058   return jresult;
71059 }
71060
71061
71062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
71063   int jresult ;
71064   int result;
71065
71066   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
71067   jresult = (int)result;
71068   return jresult;
71069 }
71070
71071
71072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
71073   int jresult ;
71074   int result;
71075
71076   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
71077   jresult = (int)result;
71078   return jresult;
71079 }
71080
71081
71082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
71083   int jresult ;
71084   int result;
71085
71086   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
71087   jresult = (int)result;
71088   return jresult;
71089 }
71090
71091
71092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
71093   int jresult ;
71094   int result;
71095
71096   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
71097   jresult = (int)result;
71098   return jresult;
71099 }
71100
71101
71102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
71103   int jresult ;
71104   int result;
71105
71106   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
71107   jresult = (int)result;
71108   return jresult;
71109 }
71110
71111
71112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
71113   int jresult ;
71114   int result;
71115
71116   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
71117   jresult = (int)result;
71118   return jresult;
71119 }
71120
71121
71122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
71123   int jresult ;
71124   int result;
71125
71126   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
71127   jresult = (int)result;
71128   return jresult;
71129 }
71130
71131
71132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
71133   int jresult ;
71134   int result;
71135
71136   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
71137   jresult = (int)result;
71138   return jresult;
71139 }
71140
71141
71142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
71143   void * jresult ;
71144   Dali::Toolkit::ItemView::Property *result = 0 ;
71145
71146   {
71147     try {
71148       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
71149     } catch (std::out_of_range& e) {
71150       {
71151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71152       };
71153     } catch (std::exception& e) {
71154       {
71155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71156       };
71157     } catch (Dali::DaliException e) {
71158       {
71159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71160       };
71161     } catch (...) {
71162       {
71163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71164       };
71165     }
71166   }
71167
71168   jresult = (void *)result;
71169   return jresult;
71170 }
71171
71172
71173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
71174   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
71175
71176   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
71177   {
71178     try {
71179       delete arg1;
71180     } catch (std::out_of_range& e) {
71181       {
71182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71183       };
71184     } catch (std::exception& e) {
71185       {
71186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71187       };
71188     } catch (Dali::DaliException e) {
71189       {
71190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71191       };
71192     } catch (...) {
71193       {
71194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71195       };
71196     }
71197   }
71198
71199 }
71200
71201
71202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
71203   void * jresult ;
71204   Dali::Toolkit::ItemView *result = 0 ;
71205
71206   {
71207     try {
71208       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
71209     } catch (std::out_of_range& e) {
71210       {
71211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71212       };
71213     } catch (std::exception& e) {
71214       {
71215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71216       };
71217     } catch (Dali::DaliException e) {
71218       {
71219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71220       };
71221     } catch (...) {
71222       {
71223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71224       };
71225     }
71226   }
71227
71228   jresult = (void *)result;
71229   return jresult;
71230 }
71231
71232
71233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
71234   void * jresult ;
71235   Dali::Toolkit::ItemView *arg1 = 0 ;
71236   Dali::Toolkit::ItemView *result = 0 ;
71237
71238   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71239   if (!arg1) {
71240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
71241     return 0;
71242   }
71243   {
71244     try {
71245       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
71246     } catch (std::out_of_range& e) {
71247       {
71248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71249       };
71250     } catch (std::exception& e) {
71251       {
71252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71253       };
71254     } catch (Dali::DaliException e) {
71255       {
71256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71257       };
71258     } catch (...) {
71259       {
71260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71261       };
71262     }
71263   }
71264
71265   jresult = (void *)result;
71266   return jresult;
71267 }
71268
71269
71270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
71271   void * jresult ;
71272   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71273   Dali::Toolkit::ItemView *arg2 = 0 ;
71274   Dali::Toolkit::ItemView *result = 0 ;
71275
71276   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71277   arg2 = (Dali::Toolkit::ItemView *)jarg2;
71278   if (!arg2) {
71279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
71280     return 0;
71281   }
71282   {
71283     try {
71284       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
71285     } catch (std::out_of_range& e) {
71286       {
71287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71288       };
71289     } catch (std::exception& e) {
71290       {
71291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71292       };
71293     } catch (Dali::DaliException e) {
71294       {
71295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71296       };
71297     } catch (...) {
71298       {
71299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71300       };
71301     }
71302   }
71303
71304   jresult = (void *)result;
71305   return jresult;
71306 }
71307
71308
71309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
71310   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71311
71312   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71313   {
71314     try {
71315       delete arg1;
71316     } catch (std::out_of_range& e) {
71317       {
71318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71319       };
71320     } catch (std::exception& e) {
71321       {
71322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71323       };
71324     } catch (Dali::DaliException e) {
71325       {
71326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71327       };
71328     } catch (...) {
71329       {
71330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71331       };
71332     }
71333   }
71334
71335 }
71336
71337
71338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
71339   void * jresult ;
71340   Dali::Toolkit::ItemFactory *arg1 = 0 ;
71341   Dali::Toolkit::ItemView result;
71342
71343   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
71344   if (!arg1) {
71345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
71346     return 0;
71347   }
71348   {
71349     try {
71350       result = Dali::Toolkit::ItemView::New(*arg1);
71351     } catch (std::out_of_range& e) {
71352       {
71353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71354       };
71355     } catch (std::exception& e) {
71356       {
71357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71358       };
71359     } catch (Dali::DaliException e) {
71360       {
71361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71362       };
71363     } catch (...) {
71364       {
71365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71366       };
71367     }
71368   }
71369
71370   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71371   return jresult;
71372 }
71373
71374
71375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
71376   void * jresult ;
71377   Dali::BaseHandle arg1 ;
71378   Dali::BaseHandle *argp1 ;
71379   Dali::Toolkit::ItemView result;
71380
71381   argp1 = (Dali::BaseHandle *)jarg1;
71382   if (!argp1) {
71383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71384     return 0;
71385   }
71386   arg1 = *argp1;
71387   {
71388     try {
71389       result = Dali::Toolkit::ItemView::DownCast(arg1);
71390     } catch (std::out_of_range& e) {
71391       {
71392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71393       };
71394     } catch (std::exception& e) {
71395       {
71396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71397       };
71398     } catch (Dali::DaliException e) {
71399       {
71400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71401       };
71402     } catch (...) {
71403       {
71404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71405       };
71406     }
71407   }
71408
71409   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71410   return jresult;
71411 }
71412
71413
71414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
71415   unsigned int jresult ;
71416   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71417   unsigned int result;
71418
71419   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71420   {
71421     try {
71422       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
71423     } catch (std::out_of_range& e) {
71424       {
71425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71426       };
71427     } catch (std::exception& e) {
71428       {
71429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71430       };
71431     } catch (Dali::DaliException e) {
71432       {
71433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71434       };
71435     } catch (...) {
71436       {
71437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71438       };
71439     }
71440   }
71441
71442   jresult = result;
71443   return jresult;
71444 }
71445
71446
71447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
71448   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71449   Dali::Toolkit::ItemLayout *arg2 = 0 ;
71450
71451   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71452   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
71453   if (!arg2) {
71454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
71455     return ;
71456   }
71457   {
71458     try {
71459       (arg1)->AddLayout(*arg2);
71460     } catch (std::out_of_range& e) {
71461       {
71462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71463       };
71464     } catch (std::exception& e) {
71465       {
71466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71467       };
71468     } catch (Dali::DaliException e) {
71469       {
71470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71471       };
71472     } catch (...) {
71473       {
71474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71475       };
71476     }
71477   }
71478
71479 }
71480
71481
71482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
71483   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71484   unsigned int arg2 ;
71485
71486   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71487   arg2 = (unsigned int)jarg2;
71488   {
71489     try {
71490       (arg1)->RemoveLayout(arg2);
71491     } catch (std::out_of_range& e) {
71492       {
71493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71494       };
71495     } catch (std::exception& e) {
71496       {
71497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71498       };
71499     } catch (Dali::DaliException e) {
71500       {
71501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71502       };
71503     } catch (...) {
71504       {
71505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71506       };
71507     }
71508   }
71509
71510 }
71511
71512
71513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
71514   void * jresult ;
71515   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71516   unsigned int arg2 ;
71517   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71518
71519   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71520   arg2 = (unsigned int)jarg2;
71521   {
71522     try {
71523       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71524     } catch (std::out_of_range& e) {
71525       {
71526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71527       };
71528     } catch (std::exception& e) {
71529       {
71530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71531       };
71532     } catch (Dali::DaliException e) {
71533       {
71534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71535       };
71536     } catch (...) {
71537       {
71538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71539       };
71540     }
71541   }
71542
71543   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71544   return jresult;
71545 }
71546
71547
71548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71549   void * jresult ;
71550   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71551   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71552
71553   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71554   {
71555     try {
71556       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71557     } catch (std::out_of_range& e) {
71558       {
71559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71560       };
71561     } catch (std::exception& e) {
71562       {
71563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71564       };
71565     } catch (Dali::DaliException e) {
71566       {
71567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71568       };
71569     } catch (...) {
71570       {
71571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71572       };
71573     }
71574   }
71575
71576   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71577   return jresult;
71578 }
71579
71580
71581 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71582   float jresult ;
71583   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71584   Dali::Toolkit::ItemId arg2 ;
71585   float result;
71586
71587   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71588   arg2 = (Dali::Toolkit::ItemId)jarg2;
71589   {
71590     try {
71591       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71592     } catch (std::out_of_range& e) {
71593       {
71594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71595       };
71596     } catch (std::exception& e) {
71597       {
71598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71599       };
71600     } catch (Dali::DaliException e) {
71601       {
71602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71603       };
71604     } catch (...) {
71605       {
71606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71607       };
71608     }
71609   }
71610
71611   jresult = result;
71612   return jresult;
71613 }
71614
71615
71616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71617   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71618   unsigned int arg2 ;
71619   Dali::Vector3 arg3 ;
71620   float arg4 ;
71621   Dali::Vector3 *argp3 ;
71622
71623   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71624   arg2 = (unsigned int)jarg2;
71625   argp3 = (Dali::Vector3 *)jarg3;
71626   if (!argp3) {
71627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71628     return ;
71629   }
71630   arg3 = *argp3;
71631   arg4 = (float)jarg4;
71632   {
71633     try {
71634       (arg1)->ActivateLayout(arg2,arg3,arg4);
71635     } catch (std::out_of_range& e) {
71636       {
71637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71638       };
71639     } catch (std::exception& e) {
71640       {
71641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71642       };
71643     } catch (Dali::DaliException e) {
71644       {
71645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71646       };
71647     } catch (...) {
71648       {
71649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71650       };
71651     }
71652   }
71653
71654 }
71655
71656
71657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71658   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71659
71660   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71661   {
71662     try {
71663       (arg1)->DeactivateCurrentLayout();
71664     } catch (std::out_of_range& e) {
71665       {
71666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71667       };
71668     } catch (std::exception& e) {
71669       {
71670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71671       };
71672     } catch (Dali::DaliException e) {
71673       {
71674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71675       };
71676     } catch (...) {
71677       {
71678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71679       };
71680     }
71681   }
71682
71683 }
71684
71685
71686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71687   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71688   float arg2 ;
71689
71690   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71691   arg2 = (float)jarg2;
71692   {
71693     try {
71694       (arg1)->SetMinimumSwipeSpeed(arg2);
71695     } catch (std::out_of_range& e) {
71696       {
71697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71698       };
71699     } catch (std::exception& e) {
71700       {
71701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71702       };
71703     } catch (Dali::DaliException e) {
71704       {
71705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71706       };
71707     } catch (...) {
71708       {
71709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71710       };
71711     }
71712   }
71713
71714 }
71715
71716
71717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71718   float jresult ;
71719   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71720   float result;
71721
71722   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71723   {
71724     try {
71725       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71726     } catch (std::out_of_range& e) {
71727       {
71728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71729       };
71730     } catch (std::exception& e) {
71731       {
71732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71733       };
71734     } catch (Dali::DaliException e) {
71735       {
71736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71737       };
71738     } catch (...) {
71739       {
71740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71741       };
71742     }
71743   }
71744
71745   jresult = result;
71746   return jresult;
71747 }
71748
71749
71750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71751   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71752   float arg2 ;
71753
71754   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71755   arg2 = (float)jarg2;
71756   {
71757     try {
71758       (arg1)->SetMinimumSwipeDistance(arg2);
71759     } catch (std::out_of_range& e) {
71760       {
71761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71762       };
71763     } catch (std::exception& e) {
71764       {
71765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71766       };
71767     } catch (Dali::DaliException e) {
71768       {
71769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71770       };
71771     } catch (...) {
71772       {
71773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71774       };
71775     }
71776   }
71777
71778 }
71779
71780
71781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71782   float jresult ;
71783   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71784   float result;
71785
71786   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71787   {
71788     try {
71789       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71790     } catch (std::out_of_range& e) {
71791       {
71792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71793       };
71794     } catch (std::exception& e) {
71795       {
71796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71797       };
71798     } catch (Dali::DaliException e) {
71799       {
71800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71801       };
71802     } catch (...) {
71803       {
71804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71805       };
71806     }
71807   }
71808
71809   jresult = result;
71810   return jresult;
71811 }
71812
71813
71814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71815   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71816   float arg2 ;
71817
71818   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71819   arg2 = (float)jarg2;
71820   {
71821     try {
71822       (arg1)->SetWheelScrollDistanceStep(arg2);
71823     } catch (std::out_of_range& e) {
71824       {
71825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71826       };
71827     } catch (std::exception& e) {
71828       {
71829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71830       };
71831     } catch (Dali::DaliException e) {
71832       {
71833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71834       };
71835     } catch (...) {
71836       {
71837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71838       };
71839     }
71840   }
71841
71842 }
71843
71844
71845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71846   float jresult ;
71847   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71848   float result;
71849
71850   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71851   {
71852     try {
71853       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71854     } catch (std::out_of_range& e) {
71855       {
71856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71857       };
71858     } catch (std::exception& e) {
71859       {
71860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71861       };
71862     } catch (Dali::DaliException e) {
71863       {
71864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71865       };
71866     } catch (...) {
71867       {
71868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71869       };
71870     }
71871   }
71872
71873   jresult = result;
71874   return jresult;
71875 }
71876
71877
71878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71879   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71880   bool arg2 ;
71881
71882   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71883   arg2 = jarg2 ? true : false;
71884   {
71885     try {
71886       (arg1)->SetAnchoring(arg2);
71887     } catch (std::out_of_range& e) {
71888       {
71889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71890       };
71891     } catch (std::exception& e) {
71892       {
71893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71894       };
71895     } catch (Dali::DaliException e) {
71896       {
71897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71898       };
71899     } catch (...) {
71900       {
71901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71902       };
71903     }
71904   }
71905
71906 }
71907
71908 //// ========================= end of part 3 =============================
71909
71910 //// ========================== start part 4 ===============================
71911
71912
71913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71914   unsigned int jresult ;
71915   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71916   bool result;
71917
71918   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71919   {
71920     try {
71921       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71922     } catch (std::out_of_range& e) {
71923       {
71924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71925       };
71926     } catch (std::exception& e) {
71927       {
71928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71929       };
71930     } catch (Dali::DaliException e) {
71931       {
71932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71933       };
71934     } catch (...) {
71935       {
71936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71937       };
71938     }
71939   }
71940
71941   jresult = result;
71942   return jresult;
71943 }
71944
71945
71946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71947   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71948   float arg2 ;
71949
71950   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71951   arg2 = (float)jarg2;
71952   {
71953     try {
71954       (arg1)->SetAnchoringDuration(arg2);
71955     } catch (std::out_of_range& e) {
71956       {
71957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71958       };
71959     } catch (std::exception& e) {
71960       {
71961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71962       };
71963     } catch (Dali::DaliException e) {
71964       {
71965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71966       };
71967     } catch (...) {
71968       {
71969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71970       };
71971     }
71972   }
71973
71974 }
71975
71976
71977 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71978   float jresult ;
71979   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71980   float result;
71981
71982   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71983   {
71984     try {
71985       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71986     } catch (std::out_of_range& e) {
71987       {
71988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71989       };
71990     } catch (std::exception& e) {
71991       {
71992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71993       };
71994     } catch (Dali::DaliException e) {
71995       {
71996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71997       };
71998     } catch (...) {
71999       {
72000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72001       };
72002     }
72003   }
72004
72005   jresult = result;
72006   return jresult;
72007 }
72008
72009
72010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
72011   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72012   Dali::Toolkit::ItemId arg2 ;
72013   float arg3 ;
72014
72015   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72016   arg2 = (Dali::Toolkit::ItemId)jarg2;
72017   arg3 = (float)jarg3;
72018   {
72019     try {
72020       (arg1)->ScrollToItem(arg2,arg3);
72021     } catch (std::out_of_range& e) {
72022       {
72023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72024       };
72025     } catch (std::exception& e) {
72026       {
72027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72028       };
72029     } catch (Dali::DaliException e) {
72030       {
72031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72032       };
72033     } catch (...) {
72034       {
72035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72036       };
72037     }
72038   }
72039
72040 }
72041
72042
72043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
72044   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72045   float arg2 ;
72046
72047   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72048   arg2 = (float)jarg2;
72049   {
72050     try {
72051       (arg1)->SetRefreshInterval(arg2);
72052     } catch (std::out_of_range& e) {
72053       {
72054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72055       };
72056     } catch (std::exception& e) {
72057       {
72058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72059       };
72060     } catch (Dali::DaliException e) {
72061       {
72062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72063       };
72064     } catch (...) {
72065       {
72066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72067       };
72068     }
72069   }
72070
72071 }
72072
72073
72074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
72075   float jresult ;
72076   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72077   float result;
72078
72079   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72080   {
72081     try {
72082       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
72083     } catch (std::out_of_range& e) {
72084       {
72085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72086       };
72087     } catch (std::exception& e) {
72088       {
72089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72090       };
72091     } catch (Dali::DaliException e) {
72092       {
72093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72094       };
72095     } catch (...) {
72096       {
72097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72098       };
72099     }
72100   }
72101
72102   jresult = result;
72103   return jresult;
72104 }
72105
72106
72107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
72108   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72109
72110   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72111   {
72112     try {
72113       (arg1)->Refresh();
72114     } catch (std::out_of_range& e) {
72115       {
72116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72117       };
72118     } catch (std::exception& e) {
72119       {
72120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72121       };
72122     } catch (Dali::DaliException e) {
72123       {
72124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72125       };
72126     } catch (...) {
72127       {
72128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72129       };
72130     }
72131   }
72132
72133 }
72134
72135
72136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
72137   void * jresult ;
72138   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72139   Dali::Toolkit::ItemId arg2 ;
72140   Dali::Actor result;
72141
72142   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72143   arg2 = (Dali::Toolkit::ItemId)jarg2;
72144   {
72145     try {
72146       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
72147     } catch (std::out_of_range& e) {
72148       {
72149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72150       };
72151     } catch (std::exception& e) {
72152       {
72153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72154       };
72155     } catch (Dali::DaliException e) {
72156       {
72157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72158       };
72159     } catch (...) {
72160       {
72161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72162       };
72163     }
72164   }
72165
72166   jresult = new Dali::Actor((const Dali::Actor &)result);
72167   return jresult;
72168 }
72169
72170
72171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
72172   unsigned int jresult ;
72173   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72174   Dali::Actor arg2 ;
72175   Dali::Actor *argp2 ;
72176   Dali::Toolkit::ItemId result;
72177
72178   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72179   argp2 = (Dali::Actor *)jarg2;
72180   if (!argp2) {
72181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72182     return 0;
72183   }
72184   arg2 = *argp2;
72185   {
72186     try {
72187       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
72188     } catch (std::out_of_range& e) {
72189       {
72190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72191       };
72192     } catch (std::exception& e) {
72193       {
72194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72195       };
72196     } catch (Dali::DaliException e) {
72197       {
72198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72199       };
72200     } catch (...) {
72201       {
72202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72203       };
72204     }
72205   }
72206
72207   jresult = result;
72208   return jresult;
72209 }
72210
72211
72212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
72213   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72214   Dali::Toolkit::Item arg2 ;
72215   float arg3 ;
72216   Dali::Toolkit::Item *argp2 ;
72217
72218   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72219   argp2 = (Dali::Toolkit::Item *)jarg2;
72220   if (!argp2) {
72221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
72222     return ;
72223   }
72224   arg2 = *argp2;
72225   arg3 = (float)jarg3;
72226   {
72227     try {
72228       (arg1)->InsertItem(arg2,arg3);
72229     } catch (std::out_of_range& e) {
72230       {
72231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72232       };
72233     } catch (std::exception& e) {
72234       {
72235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72236       };
72237     } catch (Dali::DaliException e) {
72238       {
72239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72240       };
72241     } catch (...) {
72242       {
72243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72244       };
72245     }
72246   }
72247
72248 }
72249
72250
72251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
72252   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72253   Dali::Toolkit::ItemContainer *arg2 = 0 ;
72254   float arg3 ;
72255
72256   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72257   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
72258   if (!arg2) {
72259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
72260     return ;
72261   }
72262   arg3 = (float)jarg3;
72263   {
72264     try {
72265       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
72266     } catch (std::out_of_range& e) {
72267       {
72268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72269       };
72270     } catch (std::exception& e) {
72271       {
72272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72273       };
72274     } catch (Dali::DaliException e) {
72275       {
72276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72277       };
72278     } catch (...) {
72279       {
72280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72281       };
72282     }
72283   }
72284
72285 }
72286
72287
72288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
72289   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72290   Dali::Toolkit::ItemId arg2 ;
72291   float arg3 ;
72292
72293   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72294   arg2 = (Dali::Toolkit::ItemId)jarg2;
72295   arg3 = (float)jarg3;
72296   {
72297     try {
72298       (arg1)->RemoveItem(arg2,arg3);
72299     } catch (std::out_of_range& e) {
72300       {
72301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72302       };
72303     } catch (std::exception& e) {
72304       {
72305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72306       };
72307     } catch (Dali::DaliException e) {
72308       {
72309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72310       };
72311     } catch (...) {
72312       {
72313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72314       };
72315     }
72316   }
72317
72318 }
72319
72320
72321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
72322   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72323   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
72324   float arg3 ;
72325
72326   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72327   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
72328   if (!arg2) {
72329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
72330     return ;
72331   }
72332   arg3 = (float)jarg3;
72333   {
72334     try {
72335       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
72336     } catch (std::out_of_range& e) {
72337       {
72338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72339       };
72340     } catch (std::exception& e) {
72341       {
72342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72343       };
72344     } catch (Dali::DaliException e) {
72345       {
72346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72347       };
72348     } catch (...) {
72349       {
72350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72351       };
72352     }
72353   }
72354
72355 }
72356
72357
72358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
72359   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72360   Dali::Toolkit::Item arg2 ;
72361   float arg3 ;
72362   Dali::Toolkit::Item *argp2 ;
72363
72364   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72365   argp2 = (Dali::Toolkit::Item *)jarg2;
72366   if (!argp2) {
72367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
72368     return ;
72369   }
72370   arg2 = *argp2;
72371   arg3 = (float)jarg3;
72372   {
72373     try {
72374       (arg1)->ReplaceItem(arg2,arg3);
72375     } catch (std::out_of_range& e) {
72376       {
72377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72378       };
72379     } catch (std::exception& e) {
72380       {
72381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72382       };
72383     } catch (Dali::DaliException e) {
72384       {
72385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72386       };
72387     } catch (...) {
72388       {
72389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72390       };
72391     }
72392   }
72393
72394 }
72395
72396
72397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
72398   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72399   Dali::Toolkit::ItemContainer *arg2 = 0 ;
72400   float arg3 ;
72401
72402   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72403   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
72404   if (!arg2) {
72405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
72406     return ;
72407   }
72408   arg3 = (float)jarg3;
72409   {
72410     try {
72411       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
72412     } catch (std::out_of_range& e) {
72413       {
72414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72415       };
72416     } catch (std::exception& e) {
72417       {
72418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72419       };
72420     } catch (Dali::DaliException e) {
72421       {
72422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72423       };
72424     } catch (...) {
72425       {
72426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72427       };
72428     }
72429   }
72430
72431 }
72432
72433
72434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
72435   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72436   Dali::Vector3 *arg2 = 0 ;
72437
72438   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72439   arg2 = (Dali::Vector3 *)jarg2;
72440   if (!arg2) {
72441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72442     return ;
72443   }
72444   {
72445     try {
72446       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
72447     } catch (std::out_of_range& e) {
72448       {
72449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72450       };
72451     } catch (std::exception& e) {
72452       {
72453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72454       };
72455     } catch (Dali::DaliException e) {
72456       {
72457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72458       };
72459     } catch (...) {
72460       {
72461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72462       };
72463     }
72464   }
72465
72466 }
72467
72468
72469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
72470   void * jresult ;
72471   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72472   Dali::Vector3 result;
72473
72474   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72475   {
72476     try {
72477       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
72478     } catch (std::out_of_range& e) {
72479       {
72480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72481       };
72482     } catch (std::exception& e) {
72483       {
72484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72485       };
72486     } catch (Dali::DaliException e) {
72487       {
72488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72489       };
72490     } catch (...) {
72491       {
72492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72493       };
72494     }
72495   }
72496
72497   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72498   return jresult;
72499 }
72500
72501
72502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
72503   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72504   Dali::Vector3 *arg2 = 0 ;
72505
72506   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72507   arg2 = (Dali::Vector3 *)jarg2;
72508   if (!arg2) {
72509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72510     return ;
72511   }
72512   {
72513     try {
72514       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
72515     } catch (std::out_of_range& e) {
72516       {
72517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72518       };
72519     } catch (std::exception& e) {
72520       {
72521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72522       };
72523     } catch (Dali::DaliException e) {
72524       {
72525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72526       };
72527     } catch (...) {
72528       {
72529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72530       };
72531     }
72532   }
72533
72534 }
72535
72536
72537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
72538   void * jresult ;
72539   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72540   Dali::Vector3 result;
72541
72542   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72543   {
72544     try {
72545       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
72546     } catch (std::out_of_range& e) {
72547       {
72548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72549       };
72550     } catch (std::exception& e) {
72551       {
72552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72553       };
72554     } catch (Dali::DaliException e) {
72555       {
72556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72557       };
72558     } catch (...) {
72559       {
72560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72561       };
72562     }
72563   }
72564
72565   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72566   return jresult;
72567 }
72568
72569
72570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
72571   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72572   Dali::Toolkit::ItemRange *arg2 = 0 ;
72573
72574   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72575   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72576   if (!arg2) {
72577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
72578     return ;
72579   }
72580   {
72581     try {
72582       (arg1)->GetItemsRange(*arg2);
72583     } catch (std::out_of_range& e) {
72584       {
72585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72586       };
72587     } catch (std::exception& e) {
72588       {
72589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72590       };
72591     } catch (Dali::DaliException e) {
72592       {
72593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72594       };
72595     } catch (...) {
72596       {
72597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72598       };
72599     }
72600   }
72601
72602 }
72603
72604
72605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72606   void * jresult ;
72607   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72608   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72609
72610   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72611   {
72612     try {
72613       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72614     } catch (std::out_of_range& e) {
72615       {
72616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72617       };
72618     } catch (std::exception& e) {
72619       {
72620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72621       };
72622     } catch (Dali::DaliException e) {
72623       {
72624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72625       };
72626     } catch (...) {
72627       {
72628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72629       };
72630     }
72631   }
72632
72633   jresult = (void *)result;
72634   return jresult;
72635 }
72636
72637
72638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72639   Dali::Vector3 *arg1 = 0 ;
72640   PropertyInputContainer *arg2 = 0 ;
72641
72642   arg1 = (Dali::Vector3 *)jarg1;
72643   if (!arg1) {
72644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72645     return ;
72646   }
72647   arg2 = (PropertyInputContainer *)jarg2;
72648   if (!arg2) {
72649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72650     return ;
72651   }
72652   {
72653     try {
72654       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72655     } catch (std::out_of_range& e) {
72656       {
72657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72658       };
72659     } catch (std::exception& e) {
72660       {
72661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72662       };
72663     } catch (Dali::DaliException e) {
72664       {
72665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72666       };
72667     } catch (...) {
72668       {
72669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72670       };
72671     }
72672   }
72673
72674 }
72675
72676
72677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72678   Dali::Vector3 *arg1 = 0 ;
72679   PropertyInputContainer *arg2 = 0 ;
72680
72681   arg1 = (Dali::Vector3 *)jarg1;
72682   if (!arg1) {
72683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72684     return ;
72685   }
72686   arg2 = (PropertyInputContainer *)jarg2;
72687   if (!arg2) {
72688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72689     return ;
72690   }
72691   {
72692     try {
72693       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72694     } catch (std::out_of_range& e) {
72695       {
72696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72697       };
72698     } catch (std::exception& e) {
72699       {
72700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72701       };
72702     } catch (Dali::DaliException e) {
72703       {
72704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72705       };
72706     } catch (...) {
72707       {
72708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72709       };
72710     }
72711   }
72712
72713 }
72714
72715
72716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72717   void * jresult ;
72718   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72719
72720   {
72721     try {
72722       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72723     } catch (std::out_of_range& e) {
72724       {
72725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72726       };
72727     } catch (std::exception& e) {
72728       {
72729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72730       };
72731     } catch (Dali::DaliException e) {
72732       {
72733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72734       };
72735     } catch (...) {
72736       {
72737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72738       };
72739     }
72740   }
72741
72742   jresult = (void *)result;
72743   return jresult;
72744 }
72745
72746
72747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72748   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72749
72750   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72751   {
72752     try {
72753       delete arg1;
72754     } catch (std::out_of_range& e) {
72755       {
72756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72757       };
72758     } catch (std::exception& e) {
72759       {
72760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72761       };
72762     } catch (Dali::DaliException e) {
72763       {
72764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72765       };
72766     } catch (...) {
72767       {
72768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72769       };
72770     }
72771   }
72772
72773 }
72774
72775
72776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72777   void * jresult ;
72778   Dali::Path arg1 ;
72779   Dali::Vector3 *arg2 = 0 ;
72780   Dali::Property::Index arg3 ;
72781   Dali::Vector3 *arg4 = 0 ;
72782   unsigned int arg5 ;
72783   Dali::Path *argp1 ;
72784   Dali::Toolkit::ScrollViewPagePathEffect result;
72785
72786   argp1 = (Dali::Path *)jarg1;
72787   if (!argp1) {
72788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72789     return 0;
72790   }
72791   arg1 = *argp1;
72792   arg2 = (Dali::Vector3 *)jarg2;
72793   if (!arg2) {
72794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72795     return 0;
72796   }
72797   arg3 = (Dali::Property::Index)jarg3;
72798   arg4 = (Dali::Vector3 *)jarg4;
72799   if (!arg4) {
72800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72801     return 0;
72802   }
72803   arg5 = (unsigned int)jarg5;
72804   {
72805     try {
72806       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72807     } catch (std::out_of_range& e) {
72808       {
72809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72810       };
72811     } catch (std::exception& e) {
72812       {
72813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72814       };
72815     } catch (Dali::DaliException e) {
72816       {
72817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72818       };
72819     } catch (...) {
72820       {
72821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72822       };
72823     }
72824   }
72825
72826   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72827   return jresult;
72828 }
72829
72830
72831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72832   void * jresult ;
72833   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72834
72835   {
72836     try {
72837       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72838     } catch (std::out_of_range& e) {
72839       {
72840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72841       };
72842     } catch (std::exception& e) {
72843       {
72844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72845       };
72846     } catch (Dali::DaliException e) {
72847       {
72848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72849       };
72850     } catch (...) {
72851       {
72852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72853       };
72854     }
72855   }
72856
72857   jresult = (void *)result;
72858   return jresult;
72859 }
72860
72861
72862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72863   void * jresult ;
72864   Dali::BaseHandle arg1 ;
72865   Dali::BaseHandle *argp1 ;
72866   Dali::Toolkit::ScrollViewPagePathEffect result;
72867
72868   argp1 = (Dali::BaseHandle *)jarg1;
72869   if (!argp1) {
72870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72871     return 0;
72872   }
72873   arg1 = *argp1;
72874   {
72875     try {
72876       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72877     } catch (std::out_of_range& e) {
72878       {
72879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72880       };
72881     } catch (std::exception& e) {
72882       {
72883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72884       };
72885     } catch (Dali::DaliException e) {
72886       {
72887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72888       };
72889     } catch (...) {
72890       {
72891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72892       };
72893     }
72894   }
72895
72896   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72897   return jresult;
72898 }
72899
72900
72901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72902   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72903   Dali::Actor arg2 ;
72904   unsigned int arg3 ;
72905   Dali::Actor *argp2 ;
72906
72907   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72908   argp2 = (Dali::Actor *)jarg2;
72909   if (!argp2) {
72910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72911     return ;
72912   }
72913   arg2 = *argp2;
72914   arg3 = (unsigned int)jarg3;
72915   {
72916     try {
72917       (arg1)->ApplyToPage(arg2,arg3);
72918     } catch (std::out_of_range& e) {
72919       {
72920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72921       };
72922     } catch (std::exception& e) {
72923       {
72924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72925       };
72926     } catch (Dali::DaliException e) {
72927       {
72928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72929       };
72930     } catch (...) {
72931       {
72932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72933       };
72934     }
72935   }
72936
72937 }
72938
72939
72940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72941   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72942
72943   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72944   {
72945     try {
72946       delete arg1;
72947     } catch (std::out_of_range& e) {
72948       {
72949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72950       };
72951     } catch (std::exception& e) {
72952       {
72953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72954       };
72955     } catch (Dali::DaliException e) {
72956       {
72957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72958       };
72959     } catch (...) {
72960       {
72961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72962       };
72963     }
72964   }
72965
72966 }
72967
72968
72969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72970   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72971   Dali::Toolkit::ClampState arg2 ;
72972
72973   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72974   arg2 = (Dali::Toolkit::ClampState)jarg2;
72975   if (arg1) (arg1)->x = arg2;
72976 }
72977
72978
72979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72980   int jresult ;
72981   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72982   Dali::Toolkit::ClampState result;
72983
72984   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72985   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72986   jresult = (int)result;
72987   return jresult;
72988 }
72989
72990
72991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72992   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72993   Dali::Toolkit::ClampState arg2 ;
72994
72995   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72996   arg2 = (Dali::Toolkit::ClampState)jarg2;
72997   if (arg1) (arg1)->y = arg2;
72998 }
72999
73000
73001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
73002   int jresult ;
73003   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
73004   Dali::Toolkit::ClampState result;
73005
73006   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
73007   result = (Dali::Toolkit::ClampState) ((arg1)->y);
73008   jresult = (int)result;
73009   return jresult;
73010 }
73011
73012
73013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
73014   void * jresult ;
73015   Dali::Toolkit::ClampState2D *result = 0 ;
73016
73017   {
73018     try {
73019       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
73020     } catch (std::out_of_range& e) {
73021       {
73022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73023       };
73024     } catch (std::exception& e) {
73025       {
73026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73027       };
73028     } catch (Dali::DaliException e) {
73029       {
73030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73031       };
73032     } catch (...) {
73033       {
73034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73035       };
73036     }
73037   }
73038
73039   jresult = (void *)result;
73040   return jresult;
73041 }
73042
73043
73044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
73045   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
73046
73047   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
73048   {
73049     try {
73050       delete arg1;
73051     } catch (std::out_of_range& e) {
73052       {
73053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73054       };
73055     } catch (std::exception& e) {
73056       {
73057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73058       };
73059     } catch (Dali::DaliException e) {
73060       {
73061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73062       };
73063     } catch (...) {
73064       {
73065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73066       };
73067     }
73068   }
73069
73070 }
73071
73072
73073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
73074   void * jresult ;
73075   float arg1 ;
73076   float arg2 ;
73077   bool arg3 ;
73078   Dali::Toolkit::RulerDomain *result = 0 ;
73079
73080   arg1 = (float)jarg1;
73081   arg2 = (float)jarg2;
73082   arg3 = jarg3 ? true : false;
73083   {
73084     try {
73085       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
73086     } catch (std::out_of_range& e) {
73087       {
73088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73089       };
73090     } catch (std::exception& e) {
73091       {
73092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73093       };
73094     } catch (Dali::DaliException e) {
73095       {
73096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73097       };
73098     } catch (...) {
73099       {
73100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73101       };
73102     }
73103   }
73104
73105   jresult = (void *)result;
73106   return jresult;
73107 }
73108
73109
73110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
73111   void * jresult ;
73112   float arg1 ;
73113   float arg2 ;
73114   Dali::Toolkit::RulerDomain *result = 0 ;
73115
73116   arg1 = (float)jarg1;
73117   arg2 = (float)jarg2;
73118   {
73119     try {
73120       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
73121     } catch (std::out_of_range& e) {
73122       {
73123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73124       };
73125     } catch (std::exception& e) {
73126       {
73127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73128       };
73129     } catch (Dali::DaliException e) {
73130       {
73131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73132       };
73133     } catch (...) {
73134       {
73135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73136       };
73137     }
73138   }
73139
73140   jresult = (void *)result;
73141   return jresult;
73142 }
73143
73144
73145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
73146   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73147   float arg2 ;
73148
73149   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73150   arg2 = (float)jarg2;
73151   if (arg1) (arg1)->min = arg2;
73152 }
73153
73154
73155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
73156   float jresult ;
73157   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73158   float result;
73159
73160   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73161   result = (float) ((arg1)->min);
73162   jresult = result;
73163   return jresult;
73164 }
73165
73166
73167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
73168   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73169   float arg2 ;
73170
73171   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73172   arg2 = (float)jarg2;
73173   if (arg1) (arg1)->max = arg2;
73174 }
73175
73176
73177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
73178   float jresult ;
73179   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73180   float result;
73181
73182   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73183   result = (float) ((arg1)->max);
73184   jresult = result;
73185   return jresult;
73186 }
73187
73188
73189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
73190   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73191   bool arg2 ;
73192
73193   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73194   arg2 = jarg2 ? true : false;
73195   if (arg1) (arg1)->enabled = arg2;
73196 }
73197
73198
73199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
73200   unsigned int jresult ;
73201   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73202   bool result;
73203
73204   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73205   result = (bool) ((arg1)->enabled);
73206   jresult = result;
73207   return jresult;
73208 }
73209
73210
73211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73212   float jresult ;
73213   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73214   float arg2 ;
73215   float arg3 ;
73216   float arg4 ;
73217   float result;
73218
73219   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73220   arg2 = (float)jarg2;
73221   arg3 = (float)jarg3;
73222   arg4 = (float)jarg4;
73223   {
73224     try {
73225       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
73226     } catch (std::out_of_range& e) {
73227       {
73228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73229       };
73230     } catch (std::exception& e) {
73231       {
73232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73233       };
73234     } catch (Dali::DaliException e) {
73235       {
73236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73237       };
73238     } catch (...) {
73239       {
73240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73241       };
73242     }
73243   }
73244
73245   jresult = result;
73246   return jresult;
73247 }
73248
73249
73250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73251   float jresult ;
73252   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73253   float arg2 ;
73254   float arg3 ;
73255   float result;
73256
73257   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73258   arg2 = (float)jarg2;
73259   arg3 = (float)jarg3;
73260   {
73261     try {
73262       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
73263     } catch (std::out_of_range& e) {
73264       {
73265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73266       };
73267     } catch (std::exception& e) {
73268       {
73269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73270       };
73271     } catch (Dali::DaliException e) {
73272       {
73273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73274       };
73275     } catch (...) {
73276       {
73277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73278       };
73279     }
73280   }
73281
73282   jresult = result;
73283   return jresult;
73284 }
73285
73286
73287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
73288   float jresult ;
73289   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73290   float arg2 ;
73291   float result;
73292
73293   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73294   arg2 = (float)jarg2;
73295   {
73296     try {
73297       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
73298     } catch (std::out_of_range& e) {
73299       {
73300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73301       };
73302     } catch (std::exception& e) {
73303       {
73304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73305       };
73306     } catch (Dali::DaliException e) {
73307       {
73308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73309       };
73310     } catch (...) {
73311       {
73312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73313       };
73314     }
73315   }
73316
73317   jresult = result;
73318   return jresult;
73319 }
73320
73321
73322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73323   float jresult ;
73324   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73325   float arg2 ;
73326   float arg3 ;
73327   float arg4 ;
73328   Dali::Toolkit::ClampState *arg5 = 0 ;
73329   float result;
73330
73331   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73332   arg2 = (float)jarg2;
73333   arg3 = (float)jarg3;
73334   arg4 = (float)jarg4;
73335   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73336   if (!arg5) {
73337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73338     return 0;
73339   }
73340   {
73341     try {
73342       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73343     } catch (std::out_of_range& e) {
73344       {
73345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73346       };
73347     } catch (std::exception& e) {
73348       {
73349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73350       };
73351     } catch (Dali::DaliException e) {
73352       {
73353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73354       };
73355     } catch (...) {
73356       {
73357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73358       };
73359     }
73360   }
73361
73362   jresult = result;
73363   return jresult;
73364 }
73365
73366
73367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
73368   float jresult ;
73369   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73370   float result;
73371
73372   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73373   {
73374     try {
73375       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
73376     } catch (std::out_of_range& e) {
73377       {
73378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73379       };
73380     } catch (std::exception& e) {
73381       {
73382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73383       };
73384     } catch (Dali::DaliException e) {
73385       {
73386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73387       };
73388     } catch (...) {
73389       {
73390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73391       };
73392     }
73393   }
73394
73395   jresult = result;
73396   return jresult;
73397 }
73398
73399
73400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
73401   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73402
73403   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73404   {
73405     try {
73406       delete arg1;
73407     } catch (std::out_of_range& e) {
73408       {
73409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73410       };
73411     } catch (std::exception& e) {
73412       {
73413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73414       };
73415     } catch (Dali::DaliException e) {
73416       {
73417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73418       };
73419     } catch (...) {
73420       {
73421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73422       };
73423     }
73424   }
73425
73426 }
73427
73428
73429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
73430   float jresult ;
73431   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73432   float arg2 ;
73433   float arg3 ;
73434   float result;
73435
73436   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73437   arg2 = (float)jarg2;
73438   arg3 = (float)jarg3;
73439   {
73440     try {
73441       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
73442     } catch (std::out_of_range& e) {
73443       {
73444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73445       };
73446     } catch (std::exception& e) {
73447       {
73448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73449       };
73450     } catch (Dali::DaliException e) {
73451       {
73452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73453       };
73454     } catch (...) {
73455       {
73456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73457       };
73458     }
73459   }
73460
73461   jresult = result;
73462   return jresult;
73463 }
73464
73465
73466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
73467   float jresult ;
73468   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73469   float arg2 ;
73470   float result;
73471
73472   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73473   arg2 = (float)jarg2;
73474   {
73475     try {
73476       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
73477     } catch (std::out_of_range& e) {
73478       {
73479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73480       };
73481     } catch (std::exception& e) {
73482       {
73483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73484       };
73485     } catch (Dali::DaliException e) {
73486       {
73487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73488       };
73489     } catch (...) {
73490       {
73491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73492       };
73493     }
73494   }
73495
73496   jresult = result;
73497   return jresult;
73498 }
73499
73500
73501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73502   float jresult ;
73503   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73504   unsigned int arg2 ;
73505   unsigned int *arg3 = 0 ;
73506   bool arg4 ;
73507   float result;
73508
73509   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73510   arg2 = (unsigned int)jarg2;
73511   arg3 = (unsigned int *)jarg3;
73512   arg4 = jarg4 ? true : false;
73513   {
73514     try {
73515       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73516     } catch (std::out_of_range& e) {
73517       {
73518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73519       };
73520     } catch (std::exception& e) {
73521       {
73522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73523       };
73524     } catch (Dali::DaliException e) {
73525       {
73526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73527       };
73528     } catch (...) {
73529       {
73530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73531       };
73532     }
73533   }
73534
73535   jresult = result;
73536   return jresult;
73537 }
73538
73539
73540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73541   unsigned int jresult ;
73542   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73543   float arg2 ;
73544   bool arg3 ;
73545   unsigned int result;
73546
73547   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73548   arg2 = (float)jarg2;
73549   arg3 = jarg3 ? true : false;
73550   {
73551     try {
73552       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
73553     } catch (std::out_of_range& e) {
73554       {
73555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73556       };
73557     } catch (std::exception& e) {
73558       {
73559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73560       };
73561     } catch (Dali::DaliException e) {
73562       {
73563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73564       };
73565     } catch (...) {
73566       {
73567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73568       };
73569     }
73570   }
73571
73572   jresult = result;
73573   return jresult;
73574 }
73575
73576
73577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
73578   unsigned int jresult ;
73579   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73580   unsigned int result;
73581
73582   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73583   {
73584     try {
73585       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
73586     } catch (std::out_of_range& e) {
73587       {
73588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73589       };
73590     } catch (std::exception& e) {
73591       {
73592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73593       };
73594     } catch (Dali::DaliException e) {
73595       {
73596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73597       };
73598     } catch (...) {
73599       {
73600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73601       };
73602     }
73603   }
73604
73605   jresult = result;
73606   return jresult;
73607 }
73608
73609
73610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
73611   int jresult ;
73612   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73613   Dali::Toolkit::Ruler::RulerType result;
73614
73615   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73616   {
73617     try {
73618       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
73619     } catch (std::out_of_range& e) {
73620       {
73621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73622       };
73623     } catch (std::exception& e) {
73624       {
73625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73626       };
73627     } catch (Dali::DaliException e) {
73628       {
73629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73630       };
73631     } catch (...) {
73632       {
73633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73634       };
73635     }
73636   }
73637
73638   jresult = (int)result;
73639   return jresult;
73640 }
73641
73642
73643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
73644   unsigned int jresult ;
73645   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73646   bool result;
73647
73648   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73649   {
73650     try {
73651       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
73652     } catch (std::out_of_range& e) {
73653       {
73654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73655       };
73656     } catch (std::exception& e) {
73657       {
73658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73659       };
73660     } catch (Dali::DaliException e) {
73661       {
73662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73663       };
73664     } catch (...) {
73665       {
73666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73667       };
73668     }
73669   }
73670
73671   jresult = result;
73672   return jresult;
73673 }
73674
73675
73676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
73677   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73678
73679   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73680   {
73681     try {
73682       (arg1)->Enable();
73683     } catch (std::out_of_range& e) {
73684       {
73685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73686       };
73687     } catch (std::exception& e) {
73688       {
73689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73690       };
73691     } catch (Dali::DaliException e) {
73692       {
73693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73694       };
73695     } catch (...) {
73696       {
73697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73698       };
73699     }
73700   }
73701
73702 }
73703
73704
73705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73706   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73707
73708   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73709   {
73710     try {
73711       (arg1)->Disable();
73712     } catch (std::out_of_range& e) {
73713       {
73714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73715       };
73716     } catch (std::exception& e) {
73717       {
73718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73719       };
73720     } catch (Dali::DaliException e) {
73721       {
73722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73723       };
73724     } catch (...) {
73725       {
73726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73727       };
73728     }
73729   }
73730
73731 }
73732
73733
73734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73735   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73736   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73737   Dali::Toolkit::RulerDomain *argp2 ;
73738
73739   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73740   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73741   if (!argp2) {
73742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73743     return ;
73744   }
73745   arg2 = *argp2;
73746   {
73747     try {
73748       (arg1)->SetDomain(arg2);
73749     } catch (std::out_of_range& e) {
73750       {
73751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73752       };
73753     } catch (std::exception& e) {
73754       {
73755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73756       };
73757     } catch (Dali::DaliException e) {
73758       {
73759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73760       };
73761     } catch (...) {
73762       {
73763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73764       };
73765     }
73766   }
73767
73768 }
73769
73770
73771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73772   void * jresult ;
73773   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73774   Dali::Toolkit::RulerDomain *result = 0 ;
73775
73776   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73777   {
73778     try {
73779       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73780     } catch (std::out_of_range& e) {
73781       {
73782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73783       };
73784     } catch (std::exception& e) {
73785       {
73786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73787       };
73788     } catch (Dali::DaliException e) {
73789       {
73790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73791       };
73792     } catch (...) {
73793       {
73794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73795       };
73796     }
73797   }
73798
73799   jresult = (void *)result;
73800   return jresult;
73801 }
73802
73803
73804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73805   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73806
73807   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73808   {
73809     try {
73810       (arg1)->DisableDomain();
73811     } catch (std::out_of_range& e) {
73812       {
73813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73814       };
73815     } catch (std::exception& e) {
73816       {
73817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73818       };
73819     } catch (Dali::DaliException e) {
73820       {
73821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73822       };
73823     } catch (...) {
73824       {
73825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73826       };
73827     }
73828   }
73829
73830 }
73831
73832
73833 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73834   float jresult ;
73835   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73836   float arg2 ;
73837   float arg3 ;
73838   float arg4 ;
73839   float result;
73840
73841   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73842   arg2 = (float)jarg2;
73843   arg3 = (float)jarg3;
73844   arg4 = (float)jarg4;
73845   {
73846     try {
73847       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
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 = result;
73868   return jresult;
73869 }
73870
73871
73872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73873   float jresult ;
73874   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73875   float arg2 ;
73876   float arg3 ;
73877   float result;
73878
73879   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73880   arg2 = (float)jarg2;
73881   arg3 = (float)jarg3;
73882   {
73883     try {
73884       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(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_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73910   float jresult ;
73911   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73912   float arg2 ;
73913   float result;
73914
73915   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73916   arg2 = (float)jarg2;
73917   {
73918     try {
73919       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73920     } catch (std::out_of_range& e) {
73921       {
73922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73923       };
73924     } catch (std::exception& e) {
73925       {
73926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73927       };
73928     } catch (Dali::DaliException e) {
73929       {
73930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73931       };
73932     } catch (...) {
73933       {
73934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73935       };
73936     }
73937   }
73938
73939   jresult = result;
73940   return jresult;
73941 }
73942
73943
73944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73945   float jresult ;
73946   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73947   float arg2 ;
73948   float arg3 ;
73949   float arg4 ;
73950   Dali::Toolkit::ClampState *arg5 = 0 ;
73951   float result;
73952
73953   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73954   arg2 = (float)jarg2;
73955   arg3 = (float)jarg3;
73956   arg4 = (float)jarg4;
73957   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73958   if (!arg5) {
73959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73960     return 0;
73961   }
73962   {
73963     try {
73964       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73965     } catch (std::out_of_range& e) {
73966       {
73967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73968       };
73969     } catch (std::exception& e) {
73970       {
73971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73972       };
73973     } catch (Dali::DaliException e) {
73974       {
73975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73976       };
73977     } catch (...) {
73978       {
73979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73980       };
73981     }
73982   }
73983
73984   jresult = result;
73985   return jresult;
73986 }
73987
73988
73989 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73990   float jresult ;
73991   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73992   float arg2 ;
73993   float arg3 ;
73994   float arg4 ;
73995   float arg5 ;
73996   float result;
73997
73998   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73999   arg2 = (float)jarg2;
74000   arg3 = (float)jarg3;
74001   arg4 = (float)jarg4;
74002   arg5 = (float)jarg5;
74003   {
74004     try {
74005       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
74006     } catch (std::out_of_range& e) {
74007       {
74008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74009       };
74010     } catch (std::exception& e) {
74011       {
74012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74013       };
74014     } catch (Dali::DaliException e) {
74015       {
74016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74017       };
74018     } catch (...) {
74019       {
74020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74021       };
74022     }
74023   }
74024
74025   jresult = result;
74026   return jresult;
74027 }
74028
74029
74030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
74031   float jresult ;
74032   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74033   float arg2 ;
74034   float arg3 ;
74035   float arg4 ;
74036   float result;
74037
74038   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74039   arg2 = (float)jarg2;
74040   arg3 = (float)jarg3;
74041   arg4 = (float)jarg4;
74042   {
74043     try {
74044       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
74045     } catch (std::out_of_range& e) {
74046       {
74047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74048       };
74049     } catch (std::exception& e) {
74050       {
74051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74052       };
74053     } catch (Dali::DaliException e) {
74054       {
74055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74056       };
74057     } catch (...) {
74058       {
74059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74060       };
74061     }
74062   }
74063
74064   jresult = result;
74065   return jresult;
74066 }
74067
74068
74069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
74070   float jresult ;
74071   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74072   float arg2 ;
74073   float arg3 ;
74074   float result;
74075
74076   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74077   arg2 = (float)jarg2;
74078   arg3 = (float)jarg3;
74079   {
74080     try {
74081       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
74082     } catch (std::out_of_range& e) {
74083       {
74084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74085       };
74086     } catch (std::exception& e) {
74087       {
74088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74089       };
74090     } catch (Dali::DaliException e) {
74091       {
74092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74093       };
74094     } catch (...) {
74095       {
74096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74097       };
74098     }
74099   }
74100
74101   jresult = result;
74102   return jresult;
74103 }
74104
74105
74106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
74107   float jresult ;
74108   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74109   float arg2 ;
74110   float result;
74111
74112   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74113   arg2 = (float)jarg2;
74114   {
74115     try {
74116       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
74117     } catch (std::out_of_range& e) {
74118       {
74119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74120       };
74121     } catch (std::exception& e) {
74122       {
74123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74124       };
74125     } catch (Dali::DaliException e) {
74126       {
74127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74128       };
74129     } catch (...) {
74130       {
74131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74132       };
74133     }
74134   }
74135
74136   jresult = result;
74137   return jresult;
74138 }
74139
74140
74141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
74142   float jresult ;
74143   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
74144   float arg2 ;
74145   float arg3 ;
74146   float arg4 ;
74147   float arg5 ;
74148   Dali::Toolkit::ClampState *arg6 = 0 ;
74149   float result;
74150
74151   arg1 = (Dali::Toolkit::Ruler *)jarg1;
74152   arg2 = (float)jarg2;
74153   arg3 = (float)jarg3;
74154   arg4 = (float)jarg4;
74155   arg5 = (float)jarg5;
74156   arg6 = (Dali::Toolkit::ClampState *)jarg6;
74157   if (!arg6) {
74158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
74159     return 0;
74160   }
74161   {
74162     try {
74163       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
74164     } catch (std::out_of_range& e) {
74165       {
74166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74167       };
74168     } catch (std::exception& e) {
74169       {
74170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74171       };
74172     } catch (Dali::DaliException e) {
74173       {
74174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74175       };
74176     } catch (...) {
74177       {
74178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74179       };
74180     }
74181   }
74182
74183   jresult = result;
74184   return jresult;
74185 }
74186
74187
74188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
74189   void * jresult ;
74190   Dali::Toolkit::DefaultRuler *result = 0 ;
74191
74192   {
74193     try {
74194       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
74195     } catch (std::out_of_range& e) {
74196       {
74197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74198       };
74199     } catch (std::exception& e) {
74200       {
74201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74202       };
74203     } catch (Dali::DaliException e) {
74204       {
74205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74206       };
74207     } catch (...) {
74208       {
74209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74210       };
74211     }
74212   }
74213
74214   jresult = (void *)result;
74215   return jresult;
74216 }
74217
74218
74219 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
74220   float jresult ;
74221   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
74222   float arg2 ;
74223   float arg3 ;
74224   float result;
74225
74226   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
74227   arg2 = (float)jarg2;
74228   arg3 = (float)jarg3;
74229   {
74230     try {
74231       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
74232     } catch (std::out_of_range& e) {
74233       {
74234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74235       };
74236     } catch (std::exception& e) {
74237       {
74238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74239       };
74240     } catch (Dali::DaliException e) {
74241       {
74242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74243       };
74244     } catch (...) {
74245       {
74246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74247       };
74248     }
74249   }
74250
74251   jresult = result;
74252   return jresult;
74253 }
74254
74255
74256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
74257   float jresult ;
74258   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
74259   unsigned int arg2 ;
74260   unsigned int *arg3 = 0 ;
74261   bool arg4 ;
74262   float result;
74263
74264   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
74265   arg2 = (unsigned int)jarg2;
74266   arg3 = (unsigned int *)jarg3;
74267   arg4 = jarg4 ? true : false;
74268   {
74269     try {
74270       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
74271     } catch (std::out_of_range& e) {
74272       {
74273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74274       };
74275     } catch (std::exception& e) {
74276       {
74277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74278       };
74279     } catch (Dali::DaliException e) {
74280       {
74281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74282       };
74283     } catch (...) {
74284       {
74285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74286       };
74287     }
74288   }
74289
74290   jresult = result;
74291   return jresult;
74292 }
74293
74294
74295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
74296   unsigned int jresult ;
74297   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
74298   float arg2 ;
74299   bool arg3 ;
74300   unsigned int result;
74301
74302   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
74303   arg2 = (float)jarg2;
74304   arg3 = jarg3 ? true : false;
74305   {
74306     try {
74307       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
74308     } catch (std::out_of_range& e) {
74309       {
74310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74311       };
74312     } catch (std::exception& e) {
74313       {
74314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74315       };
74316     } catch (Dali::DaliException e) {
74317       {
74318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74319       };
74320     } catch (...) {
74321       {
74322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74323       };
74324     }
74325   }
74326
74327   jresult = result;
74328   return jresult;
74329 }
74330
74331
74332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
74333   unsigned int jresult ;
74334   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
74335   unsigned int result;
74336
74337   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
74338   {
74339     try {
74340       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
74341     } catch (std::out_of_range& e) {
74342       {
74343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74344       };
74345     } catch (std::exception& e) {
74346       {
74347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74348       };
74349     } catch (Dali::DaliException e) {
74350       {
74351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74352       };
74353     } catch (...) {
74354       {
74355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74356       };
74357     }
74358   }
74359
74360   jresult = result;
74361   return jresult;
74362 }
74363
74364
74365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
74366   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
74367
74368   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
74369   {
74370     try {
74371       delete arg1;
74372     } catch (std::out_of_range& e) {
74373       {
74374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74375       };
74376     } catch (std::exception& e) {
74377       {
74378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74379       };
74380     } catch (Dali::DaliException e) {
74381       {
74382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74383       };
74384     } catch (...) {
74385       {
74386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74387       };
74388     }
74389   }
74390
74391 }
74392
74393
74394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
74395   void * jresult ;
74396   float arg1 ;
74397   Dali::Toolkit::FixedRuler *result = 0 ;
74398
74399   arg1 = (float)jarg1;
74400   {
74401     try {
74402       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
74403     } catch (std::out_of_range& e) {
74404       {
74405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74406       };
74407     } catch (std::exception& e) {
74408       {
74409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74410       };
74411     } catch (Dali::DaliException e) {
74412       {
74413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74414       };
74415     } catch (...) {
74416       {
74417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74418       };
74419     }
74420   }
74421
74422   jresult = (void *)result;
74423   return jresult;
74424 }
74425
74426
74427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
74428   void * jresult ;
74429   Dali::Toolkit::FixedRuler *result = 0 ;
74430
74431   {
74432     try {
74433       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
74434     } catch (std::out_of_range& e) {
74435       {
74436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74437       };
74438     } catch (std::exception& e) {
74439       {
74440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74441       };
74442     } catch (Dali::DaliException e) {
74443       {
74444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74445       };
74446     } catch (...) {
74447       {
74448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74449       };
74450     }
74451   }
74452
74453   jresult = (void *)result;
74454   return jresult;
74455 }
74456
74457
74458 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
74459   float jresult ;
74460   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74461   float arg2 ;
74462   float arg3 ;
74463   float result;
74464
74465   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74466   arg2 = (float)jarg2;
74467   arg3 = (float)jarg3;
74468   {
74469     try {
74470       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
74471     } catch (std::out_of_range& e) {
74472       {
74473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74474       };
74475     } catch (std::exception& e) {
74476       {
74477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74478       };
74479     } catch (Dali::DaliException e) {
74480       {
74481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74482       };
74483     } catch (...) {
74484       {
74485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74486       };
74487     }
74488   }
74489
74490   jresult = result;
74491   return jresult;
74492 }
74493
74494
74495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
74496   float jresult ;
74497   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74498   unsigned int arg2 ;
74499   unsigned int *arg3 = 0 ;
74500   bool arg4 ;
74501   float result;
74502
74503   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74504   arg2 = (unsigned int)jarg2;
74505   arg3 = (unsigned int *)jarg3;
74506   arg4 = jarg4 ? true : false;
74507   {
74508     try {
74509       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
74510     } catch (std::out_of_range& e) {
74511       {
74512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74513       };
74514     } catch (std::exception& e) {
74515       {
74516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74517       };
74518     } catch (Dali::DaliException e) {
74519       {
74520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74521       };
74522     } catch (...) {
74523       {
74524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74525       };
74526     }
74527   }
74528
74529   jresult = result;
74530   return jresult;
74531 }
74532
74533
74534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
74535   unsigned int jresult ;
74536   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74537   float arg2 ;
74538   bool arg3 ;
74539   unsigned int result;
74540
74541   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74542   arg2 = (float)jarg2;
74543   arg3 = jarg3 ? true : false;
74544   {
74545     try {
74546       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
74547     } catch (std::out_of_range& e) {
74548       {
74549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74550       };
74551     } catch (std::exception& e) {
74552       {
74553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74554       };
74555     } catch (Dali::DaliException e) {
74556       {
74557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74558       };
74559     } catch (...) {
74560       {
74561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74562       };
74563     }
74564   }
74565
74566   jresult = result;
74567   return jresult;
74568 }
74569
74570
74571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
74572   unsigned int jresult ;
74573   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74574   unsigned int result;
74575
74576   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74577   {
74578     try {
74579       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
74580     } catch (std::out_of_range& e) {
74581       {
74582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74583       };
74584     } catch (std::exception& e) {
74585       {
74586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74587       };
74588     } catch (Dali::DaliException e) {
74589       {
74590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74591       };
74592     } catch (...) {
74593       {
74594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74595       };
74596     }
74597   }
74598
74599   jresult = result;
74600   return jresult;
74601 }
74602
74603
74604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
74605   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74606
74607   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74608   {
74609     try {
74610       delete arg1;
74611     } catch (std::out_of_range& e) {
74612       {
74613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74614       };
74615     } catch (std::exception& e) {
74616       {
74617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74618       };
74619     } catch (Dali::DaliException e) {
74620       {
74621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74622       };
74623     } catch (...) {
74624       {
74625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74626       };
74627     }
74628   }
74629
74630 }
74631
74632
74633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
74634   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74635   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74636
74637   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74638   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74639   if (arg1) (arg1)->scale = *arg2;
74640 }
74641
74642
74643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
74644   void * jresult ;
74645   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74646   Dali::Toolkit::ClampState2D *result = 0 ;
74647
74648   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74649   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
74650   jresult = (void *)result;
74651   return jresult;
74652 }
74653
74654
74655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
74656   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74657   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74658
74659   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74660   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74661   if (arg1) (arg1)->position = *arg2;
74662 }
74663
74664
74665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
74666   void * jresult ;
74667   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74668   Dali::Toolkit::ClampState2D *result = 0 ;
74669
74670   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74671   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
74672   jresult = (void *)result;
74673   return jresult;
74674 }
74675
74676
74677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
74678   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74679   Dali::Toolkit::ClampState arg2 ;
74680
74681   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74682   arg2 = (Dali::Toolkit::ClampState)jarg2;
74683   if (arg1) (arg1)->rotation = arg2;
74684 }
74685
74686
74687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
74688   int jresult ;
74689   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74690   Dali::Toolkit::ClampState result;
74691
74692   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74693   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
74694   jresult = (int)result;
74695   return jresult;
74696 }
74697
74698
74699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
74700   void * jresult ;
74701   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
74702
74703   {
74704     try {
74705       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
74706     } catch (std::out_of_range& e) {
74707       {
74708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74709       };
74710     } catch (std::exception& e) {
74711       {
74712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74713       };
74714     } catch (Dali::DaliException e) {
74715       {
74716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74717       };
74718     } catch (...) {
74719       {
74720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74721       };
74722     }
74723   }
74724
74725   jresult = (void *)result;
74726   return jresult;
74727 }
74728
74729
74730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
74731   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74732
74733   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74734   {
74735     try {
74736       delete arg1;
74737     } catch (std::out_of_range& e) {
74738       {
74739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74740       };
74741     } catch (std::exception& e) {
74742       {
74743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74744       };
74745     } catch (Dali::DaliException e) {
74746       {
74747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74748       };
74749     } catch (...) {
74750       {
74751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74752       };
74753     }
74754   }
74755
74756 }
74757
74758
74759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
74760   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74761   Dali::Toolkit::SnapType arg2 ;
74762
74763   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74764   arg2 = (Dali::Toolkit::SnapType)jarg2;
74765   if (arg1) (arg1)->type = arg2;
74766 }
74767
74768
74769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74770   int jresult ;
74771   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74772   Dali::Toolkit::SnapType result;
74773
74774   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74775   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74776   jresult = (int)result;
74777   return jresult;
74778 }
74779
74780
74781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74782   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74783   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74784
74785   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74786   arg2 = (Dali::Vector2 *)jarg2;
74787   if (arg1) (arg1)->position = *arg2;
74788 }
74789
74790
74791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74792   void * jresult ;
74793   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74794   Dali::Vector2 *result = 0 ;
74795
74796   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74797   result = (Dali::Vector2 *)& ((arg1)->position);
74798   jresult = (void *)result;
74799   return jresult;
74800 }
74801
74802
74803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74804   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74805   float arg2 ;
74806
74807   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74808   arg2 = (float)jarg2;
74809   if (arg1) (arg1)->duration = arg2;
74810 }
74811
74812
74813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74814   float jresult ;
74815   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74816   float result;
74817
74818   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74819   result = (float) ((arg1)->duration);
74820   jresult = result;
74821   return jresult;
74822 }
74823
74824
74825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74826   void * jresult ;
74827   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74828
74829   {
74830     try {
74831       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74832     } catch (std::out_of_range& e) {
74833       {
74834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74835       };
74836     } catch (std::exception& e) {
74837       {
74838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74839       };
74840     } catch (Dali::DaliException e) {
74841       {
74842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74843       };
74844     } catch (...) {
74845       {
74846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74847       };
74848     }
74849   }
74850
74851   jresult = (void *)result;
74852   return jresult;
74853 }
74854
74855
74856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74857   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74858
74859   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74860   {
74861     try {
74862       delete arg1;
74863     } catch (std::out_of_range& e) {
74864       {
74865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74866       };
74867     } catch (std::exception& e) {
74868       {
74869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74870       };
74871     } catch (Dali::DaliException e) {
74872       {
74873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74874       };
74875     } catch (...) {
74876       {
74877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74878       };
74879     }
74880   }
74881
74882 }
74883
74884
74885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74886   int jresult ;
74887   int result;
74888
74889   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74890   jresult = (int)result;
74891   return jresult;
74892 }
74893
74894
74895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74896   int jresult ;
74897   int result;
74898
74899   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74900   jresult = (int)result;
74901   return jresult;
74902 }
74903
74904
74905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74906   int jresult ;
74907   int result;
74908
74909   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74910   jresult = (int)result;
74911   return jresult;
74912 }
74913
74914
74915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74916   int jresult ;
74917   int result;
74918
74919   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74920   jresult = (int)result;
74921   return jresult;
74922 }
74923
74924
74925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74926   int jresult ;
74927   int result;
74928
74929   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74930   jresult = (int)result;
74931   return jresult;
74932 }
74933
74934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74935   int jresult ;
74936   int result;
74937
74938   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74939   jresult = (int)result;
74940   return jresult;
74941 }
74942
74943
74944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74945   int jresult ;
74946   int result;
74947
74948   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74949   jresult = (int)result;
74950   return jresult;
74951 }
74952
74953
74954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74955   int jresult ;
74956   int result;
74957
74958   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74959   jresult = (int)result;
74960   return jresult;
74961 }
74962
74963
74964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74965   int jresult ;
74966   int result;
74967
74968   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74969   jresult = (int)result;
74970   return jresult;
74971 }
74972
74973
74974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74975   int jresult ;
74976   int result;
74977
74978   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74979   jresult = (int)result;
74980   return jresult;
74981 }
74982
74983
74984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74985   int jresult ;
74986   int result;
74987
74988   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74989   jresult = (int)result;
74990   return jresult;
74991 }
74992
74993
74994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74995   int jresult ;
74996   int result;
74997
74998   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74999   jresult = (int)result;
75000   return jresult;
75001 }
75002
75003
75004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
75005   int jresult ;
75006   int result;
75007
75008   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
75009   jresult = (int)result;
75010   return jresult;
75011 }
75012
75013
75014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
75015   int jresult ;
75016   int result;
75017
75018   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
75019   jresult = (int)result;
75020   return jresult;
75021 }
75022
75023
75024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
75025   int jresult ;
75026   int result;
75027
75028   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
75029   jresult = (int)result;
75030   return jresult;
75031 }
75032
75033
75034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
75035   int jresult ;
75036   int result;
75037
75038   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
75039   jresult = (int)result;
75040   return jresult;
75041 }
75042
75043
75044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
75045   int jresult ;
75046   int result;
75047
75048   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
75049   jresult = (int)result;
75050   return jresult;
75051 }
75052
75053
75054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
75055   int jresult ;
75056   int result;
75057
75058   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
75059   jresult = (int)result;
75060   return jresult;
75061 }
75062
75063
75064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
75065   int jresult ;
75066   int result;
75067
75068   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
75069   jresult = (int)result;
75070   return jresult;
75071 }
75072
75073
75074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
75075   int jresult ;
75076   int result;
75077
75078   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
75079   jresult = (int)result;
75080   return jresult;
75081 }
75082
75083
75084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
75085   int jresult ;
75086   int result;
75087
75088   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
75089   jresult = (int)result;
75090   return jresult;
75091 }
75092
75093
75094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
75095   int jresult ;
75096   int result;
75097
75098   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
75099   jresult = (int)result;
75100   return jresult;
75101 }
75102
75103
75104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
75105   int jresult ;
75106   int result;
75107
75108   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
75109   jresult = (int)result;
75110   return jresult;
75111 }
75112
75113
75114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
75115   int jresult ;
75116   int result;
75117
75118   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
75119   jresult = (int)result;
75120   return jresult;
75121 }
75122
75123
75124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
75125   int jresult ;
75126   int result;
75127
75128   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
75129   jresult = (int)result;
75130   return jresult;
75131 }
75132
75133
75134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
75135   int jresult ;
75136   int result;
75137
75138   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
75139   jresult = (int)result;
75140   return jresult;
75141 }
75142
75143
75144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
75145   void * jresult ;
75146   Dali::Toolkit::ScrollView::Property *result = 0 ;
75147
75148   {
75149     try {
75150       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
75151     } catch (std::out_of_range& e) {
75152       {
75153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75154       };
75155     } catch (std::exception& e) {
75156       {
75157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75158       };
75159     } catch (Dali::DaliException e) {
75160       {
75161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75162       };
75163     } catch (...) {
75164       {
75165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75166       };
75167     }
75168   }
75169
75170   jresult = (void *)result;
75171   return jresult;
75172 }
75173
75174
75175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
75176   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
75177
75178   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
75179   {
75180     try {
75181       delete arg1;
75182     } catch (std::out_of_range& e) {
75183       {
75184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75185       };
75186     } catch (std::exception& e) {
75187       {
75188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75189       };
75190     } catch (Dali::DaliException e) {
75191       {
75192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75193       };
75194     } catch (...) {
75195       {
75196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75197       };
75198     }
75199   }
75200
75201 }
75202
75203
75204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
75205   void * jresult ;
75206   Dali::Toolkit::ScrollView *result = 0 ;
75207
75208   {
75209     try {
75210       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
75211     } catch (std::out_of_range& e) {
75212       {
75213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75214       };
75215     } catch (std::exception& e) {
75216       {
75217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75218       };
75219     } catch (Dali::DaliException e) {
75220       {
75221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75222       };
75223     } catch (...) {
75224       {
75225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75226       };
75227     }
75228   }
75229
75230   jresult = (void *)result;
75231   return jresult;
75232 }
75233
75234
75235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
75236   void * jresult ;
75237   Dali::Toolkit::ScrollView *arg1 = 0 ;
75238   Dali::Toolkit::ScrollView *result = 0 ;
75239
75240   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75241   if (!arg1) {
75242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
75243     return 0;
75244   }
75245   {
75246     try {
75247       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
75248     } catch (std::out_of_range& e) {
75249       {
75250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75251       };
75252     } catch (std::exception& e) {
75253       {
75254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75255       };
75256     } catch (Dali::DaliException e) {
75257       {
75258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75259       };
75260     } catch (...) {
75261       {
75262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75263       };
75264     }
75265   }
75266
75267   jresult = (void *)result;
75268   return jresult;
75269 }
75270
75271
75272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
75273   void * jresult ;
75274   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75275   Dali::Toolkit::ScrollView *arg2 = 0 ;
75276   Dali::Toolkit::ScrollView *result = 0 ;
75277
75278   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75279   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
75280   if (!arg2) {
75281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
75282     return 0;
75283   }
75284   {
75285     try {
75286       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
75287     } catch (std::out_of_range& e) {
75288       {
75289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75290       };
75291     } catch (std::exception& e) {
75292       {
75293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75294       };
75295     } catch (Dali::DaliException e) {
75296       {
75297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75298       };
75299     } catch (...) {
75300       {
75301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75302       };
75303     }
75304   }
75305
75306   jresult = (void *)result;
75307   return jresult;
75308 }
75309
75310
75311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
75312   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75313
75314   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75315   {
75316     try {
75317       delete arg1;
75318     } catch (std::out_of_range& e) {
75319       {
75320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75321       };
75322     } catch (std::exception& e) {
75323       {
75324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75325       };
75326     } catch (Dali::DaliException e) {
75327       {
75328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75329       };
75330     } catch (...) {
75331       {
75332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75333       };
75334     }
75335   }
75336
75337 }
75338
75339
75340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
75341   void * jresult ;
75342   Dali::Toolkit::ScrollView result;
75343
75344   {
75345     try {
75346       result = Dali::Toolkit::ScrollView::New();
75347     } catch (std::out_of_range& e) {
75348       {
75349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75350       };
75351     } catch (std::exception& e) {
75352       {
75353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75354       };
75355     } catch (Dali::DaliException e) {
75356       {
75357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75358       };
75359     } catch (...) {
75360       {
75361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75362       };
75363     }
75364   }
75365
75366   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
75367   return jresult;
75368 }
75369
75370
75371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
75372   void * jresult ;
75373   Dali::BaseHandle arg1 ;
75374   Dali::BaseHandle *argp1 ;
75375   Dali::Toolkit::ScrollView result;
75376
75377   argp1 = (Dali::BaseHandle *)jarg1;
75378   if (!argp1) {
75379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75380     return 0;
75381   }
75382   arg1 = *argp1;
75383   {
75384     try {
75385       result = Dali::Toolkit::ScrollView::DownCast(arg1);
75386     } catch (std::out_of_range& e) {
75387       {
75388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75389       };
75390     } catch (std::exception& e) {
75391       {
75392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75393       };
75394     } catch (Dali::DaliException e) {
75395       {
75396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75397       };
75398     } catch (...) {
75399       {
75400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75401       };
75402     }
75403   }
75404
75405   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
75406   return jresult;
75407 }
75408
75409
75410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
75411   void * jresult ;
75412   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75413   Dali::AlphaFunction result;
75414
75415   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75416   {
75417     try {
75418       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
75419     } catch (std::out_of_range& e) {
75420       {
75421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75422       };
75423     } catch (std::exception& e) {
75424       {
75425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75426       };
75427     } catch (Dali::DaliException e) {
75428       {
75429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75430       };
75431     } catch (...) {
75432       {
75433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75434       };
75435     }
75436   }
75437
75438   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
75439   return jresult;
75440 }
75441
75442
75443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
75444   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75445   Dali::AlphaFunction arg2 ;
75446   Dali::AlphaFunction *argp2 ;
75447
75448   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75449   argp2 = (Dali::AlphaFunction *)jarg2;
75450   if (!argp2) {
75451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75452     return ;
75453   }
75454   arg2 = *argp2;
75455   {
75456     try {
75457       (arg1)->SetScrollSnapAlphaFunction(arg2);
75458     } catch (std::out_of_range& e) {
75459       {
75460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75461       };
75462     } catch (std::exception& e) {
75463       {
75464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75465       };
75466     } catch (Dali::DaliException e) {
75467       {
75468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75469       };
75470     } catch (...) {
75471       {
75472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75473       };
75474     }
75475   }
75476
75477 }
75478
75479
75480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
75481   void * jresult ;
75482   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75483   Dali::AlphaFunction result;
75484
75485   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75486   {
75487     try {
75488       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
75489     } catch (std::out_of_range& e) {
75490       {
75491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75492       };
75493     } catch (std::exception& e) {
75494       {
75495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75496       };
75497     } catch (Dali::DaliException e) {
75498       {
75499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75500       };
75501     } catch (...) {
75502       {
75503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75504       };
75505     }
75506   }
75507
75508   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
75509   return jresult;
75510 }
75511
75512
75513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
75514   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75515   Dali::AlphaFunction arg2 ;
75516   Dali::AlphaFunction *argp2 ;
75517
75518   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75519   argp2 = (Dali::AlphaFunction *)jarg2;
75520   if (!argp2) {
75521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75522     return ;
75523   }
75524   arg2 = *argp2;
75525   {
75526     try {
75527       (arg1)->SetScrollFlickAlphaFunction(arg2);
75528     } catch (std::out_of_range& e) {
75529       {
75530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75531       };
75532     } catch (std::exception& e) {
75533       {
75534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75535       };
75536     } catch (Dali::DaliException e) {
75537       {
75538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75539       };
75540     } catch (...) {
75541       {
75542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75543       };
75544     }
75545   }
75546
75547 }
75548
75549
75550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
75551   float jresult ;
75552   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75553   float result;
75554
75555   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75556   {
75557     try {
75558       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
75559     } catch (std::out_of_range& e) {
75560       {
75561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75562       };
75563     } catch (std::exception& e) {
75564       {
75565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75566       };
75567     } catch (Dali::DaliException e) {
75568       {
75569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75570       };
75571     } catch (...) {
75572       {
75573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75574       };
75575     }
75576   }
75577
75578   jresult = result;
75579   return jresult;
75580 }
75581
75582
75583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
75584   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75585   float arg2 ;
75586
75587   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75588   arg2 = (float)jarg2;
75589   {
75590     try {
75591       (arg1)->SetScrollSnapDuration(arg2);
75592     } catch (std::out_of_range& e) {
75593       {
75594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75595       };
75596     } catch (std::exception& e) {
75597       {
75598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75599       };
75600     } catch (Dali::DaliException e) {
75601       {
75602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75603       };
75604     } catch (...) {
75605       {
75606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75607       };
75608     }
75609   }
75610
75611 }
75612
75613
75614 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
75615   float jresult ;
75616   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75617   float result;
75618
75619   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75620   {
75621     try {
75622       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
75623     } catch (std::out_of_range& e) {
75624       {
75625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75626       };
75627     } catch (std::exception& e) {
75628       {
75629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75630       };
75631     } catch (Dali::DaliException e) {
75632       {
75633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75634       };
75635     } catch (...) {
75636       {
75637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75638       };
75639     }
75640   }
75641
75642   jresult = result;
75643   return jresult;
75644 }
75645
75646
75647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
75648   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75649   float arg2 ;
75650
75651   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75652   arg2 = (float)jarg2;
75653   {
75654     try {
75655       (arg1)->SetScrollFlickDuration(arg2);
75656     } catch (std::out_of_range& e) {
75657       {
75658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75659       };
75660     } catch (std::exception& e) {
75661       {
75662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75663       };
75664     } catch (Dali::DaliException e) {
75665       {
75666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75667       };
75668     } catch (...) {
75669       {
75670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75671       };
75672     }
75673   }
75674
75675 }
75676
75677
75678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
75679   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75680   Dali::Toolkit::RulerPtr arg2 ;
75681   Dali::Toolkit::RulerPtr *argp2 ;
75682
75683   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75684   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75685   if (!argp2) {
75686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75687     return ;
75688   }
75689   arg2 = *argp2;
75690   {
75691     try {
75692       (arg1)->SetRulerX(arg2);
75693     } catch (std::out_of_range& e) {
75694       {
75695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75696       };
75697     } catch (std::exception& e) {
75698       {
75699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75700       };
75701     } catch (Dali::DaliException e) {
75702       {
75703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75704       };
75705     } catch (...) {
75706       {
75707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75708       };
75709     }
75710   }
75711
75712 }
75713
75714
75715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
75716   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75717   Dali::Toolkit::RulerPtr arg2 ;
75718   Dali::Toolkit::RulerPtr *argp2 ;
75719
75720   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75721   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75722   if (!argp2) {
75723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75724     return ;
75725   }
75726   arg2 = *argp2;
75727   {
75728     try {
75729       (arg1)->SetRulerY(arg2);
75730     } catch (std::out_of_range& e) {
75731       {
75732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75733       };
75734     } catch (std::exception& e) {
75735       {
75736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75737       };
75738     } catch (Dali::DaliException e) {
75739       {
75740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75741       };
75742     } catch (...) {
75743       {
75744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75745       };
75746     }
75747   }
75748
75749 }
75750
75751
75752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
75753   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75754   bool arg2 ;
75755
75756   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75757   arg2 = jarg2 ? true : false;
75758   {
75759     try {
75760       (arg1)->SetScrollSensitive(arg2);
75761     } catch (std::out_of_range& e) {
75762       {
75763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75764       };
75765     } catch (std::exception& e) {
75766       {
75767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75768       };
75769     } catch (Dali::DaliException e) {
75770       {
75771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75772       };
75773     } catch (...) {
75774       {
75775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75776       };
75777     }
75778   }
75779
75780 }
75781
75782
75783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75784   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75785   float arg2 ;
75786   float arg3 ;
75787
75788   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75789   arg2 = (float)jarg2;
75790   arg3 = (float)jarg3;
75791   {
75792     try {
75793       (arg1)->SetMaxOvershoot(arg2,arg3);
75794     } catch (std::out_of_range& e) {
75795       {
75796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75797       };
75798     } catch (std::exception& e) {
75799       {
75800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75801       };
75802     } catch (Dali::DaliException e) {
75803       {
75804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75805       };
75806     } catch (...) {
75807       {
75808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75809       };
75810     }
75811   }
75812
75813 }
75814
75815
75816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75818   Dali::AlphaFunction arg2 ;
75819   Dali::AlphaFunction *argp2 ;
75820
75821   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75822   argp2 = (Dali::AlphaFunction *)jarg2;
75823   if (!argp2) {
75824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75825     return ;
75826   }
75827   arg2 = *argp2;
75828   {
75829     try {
75830       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75831     } catch (std::out_of_range& e) {
75832       {
75833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75834       };
75835     } catch (std::exception& e) {
75836       {
75837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75838       };
75839     } catch (Dali::DaliException e) {
75840       {
75841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75842       };
75843     } catch (...) {
75844       {
75845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75846       };
75847     }
75848   }
75849
75850 }
75851
75852
75853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75854   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75855   float arg2 ;
75856
75857   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75858   arg2 = (float)jarg2;
75859   {
75860     try {
75861       (arg1)->SetSnapOvershootDuration(arg2);
75862     } catch (std::out_of_range& e) {
75863       {
75864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75865       };
75866     } catch (std::exception& e) {
75867       {
75868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75869       };
75870     } catch (Dali::DaliException e) {
75871       {
75872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75873       };
75874     } catch (...) {
75875       {
75876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75877       };
75878     }
75879   }
75880
75881 }
75882
75883
75884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75886   bool arg2 ;
75887
75888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75889   arg2 = jarg2 ? true : false;
75890   {
75891     try {
75892       (arg1)->SetActorAutoSnap(arg2);
75893     } catch (std::out_of_range& e) {
75894       {
75895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75896       };
75897     } catch (std::exception& e) {
75898       {
75899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75900       };
75901     } catch (Dali::DaliException e) {
75902       {
75903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75904       };
75905     } catch (...) {
75906       {
75907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75908       };
75909     }
75910   }
75911
75912 }
75913
75914
75915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75916   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75917   bool arg2 ;
75918
75919   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75920   arg2 = jarg2 ? true : false;
75921   {
75922     try {
75923       (arg1)->SetWrapMode(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 int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75947   int jresult ;
75948   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75949   int result;
75950
75951   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75952   {
75953     try {
75954       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
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 = result;
75975   return jresult;
75976 }
75977
75978
75979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75980   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75981   int arg2 ;
75982
75983   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75984   arg2 = (int)jarg2;
75985   {
75986     try {
75987       (arg1)->SetScrollUpdateDistance(arg2);
75988     } catch (std::out_of_range& e) {
75989       {
75990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75991       };
75992     } catch (std::exception& e) {
75993       {
75994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75995       };
75996     } catch (Dali::DaliException e) {
75997       {
75998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75999       };
76000     } catch (...) {
76001       {
76002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76003       };
76004     }
76005   }
76006
76007 }
76008
76009
76010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
76011   unsigned int jresult ;
76012   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76013   bool result;
76014
76015   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76016   {
76017     try {
76018       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
76019     } catch (std::out_of_range& e) {
76020       {
76021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76022       };
76023     } catch (std::exception& e) {
76024       {
76025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76026       };
76027     } catch (Dali::DaliException e) {
76028       {
76029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76030       };
76031     } catch (...) {
76032       {
76033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76034       };
76035     }
76036   }
76037
76038   jresult = result;
76039   return jresult;
76040 }
76041
76042
76043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
76044   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76045   bool arg2 ;
76046
76047   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76048   arg2 = jarg2 ? true : false;
76049   {
76050     try {
76051       (arg1)->SetAxisAutoLock(arg2);
76052     } catch (std::out_of_range& e) {
76053       {
76054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76055       };
76056     } catch (std::exception& e) {
76057       {
76058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76059       };
76060     } catch (Dali::DaliException e) {
76061       {
76062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76063       };
76064     } catch (...) {
76065       {
76066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76067       };
76068     }
76069   }
76070
76071 }
76072
76073
76074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
76075   float jresult ;
76076   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76077   float result;
76078
76079   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76080   {
76081     try {
76082       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
76083     } catch (std::out_of_range& e) {
76084       {
76085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76086       };
76087     } catch (std::exception& e) {
76088       {
76089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76090       };
76091     } catch (Dali::DaliException e) {
76092       {
76093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76094       };
76095     } catch (...) {
76096       {
76097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76098       };
76099     }
76100   }
76101
76102   jresult = result;
76103   return jresult;
76104 }
76105
76106
76107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
76108   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76109   float arg2 ;
76110
76111   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76112   arg2 = (float)jarg2;
76113   {
76114     try {
76115       (arg1)->SetAxisAutoLockGradient(arg2);
76116     } catch (std::out_of_range& e) {
76117       {
76118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76119       };
76120     } catch (std::exception& e) {
76121       {
76122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76123       };
76124     } catch (Dali::DaliException e) {
76125       {
76126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76127       };
76128     } catch (...) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76131       };
76132     }
76133   }
76134
76135 }
76136
76137
76138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
76139   float jresult ;
76140   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76141   float result;
76142
76143   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76144   {
76145     try {
76146       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
76147     } catch (std::out_of_range& e) {
76148       {
76149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76150       };
76151     } catch (std::exception& e) {
76152       {
76153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76154       };
76155     } catch (Dali::DaliException e) {
76156       {
76157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76158       };
76159     } catch (...) {
76160       {
76161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76162       };
76163     }
76164   }
76165
76166   jresult = result;
76167   return jresult;
76168 }
76169
76170
76171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
76172   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76173   float arg2 ;
76174
76175   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76176   arg2 = (float)jarg2;
76177   {
76178     try {
76179       (arg1)->SetFrictionCoefficient(arg2);
76180     } catch (std::out_of_range& e) {
76181       {
76182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76183       };
76184     } catch (std::exception& e) {
76185       {
76186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76187       };
76188     } catch (Dali::DaliException e) {
76189       {
76190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76191       };
76192     } catch (...) {
76193       {
76194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76195       };
76196     }
76197   }
76198
76199 }
76200
76201
76202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
76203   float jresult ;
76204   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76205   float result;
76206
76207   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76208   {
76209     try {
76210       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
76211     } catch (std::out_of_range& e) {
76212       {
76213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76214       };
76215     } catch (std::exception& e) {
76216       {
76217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76218       };
76219     } catch (Dali::DaliException e) {
76220       {
76221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76222       };
76223     } catch (...) {
76224       {
76225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76226       };
76227     }
76228   }
76229
76230   jresult = result;
76231   return jresult;
76232 }
76233
76234
76235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
76236   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76237   float arg2 ;
76238
76239   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76240   arg2 = (float)jarg2;
76241   {
76242     try {
76243       (arg1)->SetFlickSpeedCoefficient(arg2);
76244     } catch (std::out_of_range& e) {
76245       {
76246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76247       };
76248     } catch (std::exception& e) {
76249       {
76250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76251       };
76252     } catch (Dali::DaliException e) {
76253       {
76254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76255       };
76256     } catch (...) {
76257       {
76258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76259       };
76260     }
76261   }
76262
76263 }
76264
76265
76266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
76267   void * jresult ;
76268   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76269   Dali::Vector2 result;
76270
76271   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76272   {
76273     try {
76274       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
76275     } catch (std::out_of_range& e) {
76276       {
76277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76278       };
76279     } catch (std::exception& e) {
76280       {
76281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76282       };
76283     } catch (Dali::DaliException e) {
76284       {
76285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76286       };
76287     } catch (...) {
76288       {
76289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76290       };
76291     }
76292   }
76293
76294   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76295   return jresult;
76296 }
76297
76298
76299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
76300   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76301   Dali::Vector2 *arg2 = 0 ;
76302
76303   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76304   arg2 = (Dali::Vector2 *)jarg2;
76305   if (!arg2) {
76306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76307     return ;
76308   }
76309   {
76310     try {
76311       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
76312     } catch (std::out_of_range& e) {
76313       {
76314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76315       };
76316     } catch (std::exception& e) {
76317       {
76318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76319       };
76320     } catch (Dali::DaliException e) {
76321       {
76322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76323       };
76324     } catch (...) {
76325       {
76326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76327       };
76328     }
76329   }
76330
76331 }
76332
76333
76334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
76335   float jresult ;
76336   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76337   float result;
76338
76339   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76340   {
76341     try {
76342       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
76343     } catch (std::out_of_range& e) {
76344       {
76345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76346       };
76347     } catch (std::exception& e) {
76348       {
76349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76350       };
76351     } catch (Dali::DaliException e) {
76352       {
76353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76354       };
76355     } catch (...) {
76356       {
76357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76358       };
76359     }
76360   }
76361
76362   jresult = result;
76363   return jresult;
76364 }
76365
76366
76367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
76368   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76369   float arg2 ;
76370
76371   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76372   arg2 = (float)jarg2;
76373   {
76374     try {
76375       (arg1)->SetMinimumSpeedForFlick(arg2);
76376     } catch (std::out_of_range& e) {
76377       {
76378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76379       };
76380     } catch (std::exception& e) {
76381       {
76382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76383       };
76384     } catch (Dali::DaliException e) {
76385       {
76386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76387       };
76388     } catch (...) {
76389       {
76390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76391       };
76392     }
76393   }
76394
76395 }
76396
76397
76398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
76399   float jresult ;
76400   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76401   float result;
76402
76403   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76404   {
76405     try {
76406       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
76407     } catch (std::out_of_range& e) {
76408       {
76409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76410       };
76411     } catch (std::exception& e) {
76412       {
76413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76414       };
76415     } catch (Dali::DaliException e) {
76416       {
76417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76418       };
76419     } catch (...) {
76420       {
76421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76422       };
76423     }
76424   }
76425
76426   jresult = result;
76427   return jresult;
76428 }
76429
76430
76431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
76432   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76433   float arg2 ;
76434
76435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76436   arg2 = (float)jarg2;
76437   {
76438     try {
76439       (arg1)->SetMaxFlickSpeed(arg2);
76440     } catch (std::out_of_range& e) {
76441       {
76442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76443       };
76444     } catch (std::exception& e) {
76445       {
76446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76447       };
76448     } catch (Dali::DaliException e) {
76449       {
76450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76451       };
76452     } catch (...) {
76453       {
76454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76455       };
76456     }
76457   }
76458
76459 }
76460
76461
76462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
76463   void * jresult ;
76464   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76465   Dali::Vector2 result;
76466
76467   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76468   {
76469     try {
76470       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
76471     } catch (std::out_of_range& e) {
76472       {
76473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76474       };
76475     } catch (std::exception& e) {
76476       {
76477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76478       };
76479     } catch (Dali::DaliException e) {
76480       {
76481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76482       };
76483     } catch (...) {
76484       {
76485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76486       };
76487     }
76488   }
76489
76490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76491   return jresult;
76492 }
76493
76494
76495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
76496   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76497   Dali::Vector2 arg2 ;
76498   Dali::Vector2 *argp2 ;
76499
76500   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76501   argp2 = (Dali::Vector2 *)jarg2;
76502   if (!argp2) {
76503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
76504     return ;
76505   }
76506   arg2 = *argp2;
76507   {
76508     try {
76509       (arg1)->SetWheelScrollDistanceStep(arg2);
76510     } catch (std::out_of_range& e) {
76511       {
76512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76513       };
76514     } catch (std::exception& e) {
76515       {
76516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76517       };
76518     } catch (Dali::DaliException e) {
76519       {
76520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76521       };
76522     } catch (...) {
76523       {
76524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76525       };
76526     }
76527   }
76528
76529 }
76530
76531
76532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
76533   void * jresult ;
76534   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76535   Dali::Vector2 result;
76536
76537   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76538   {
76539     try {
76540       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
76541     } catch (std::out_of_range& e) {
76542       {
76543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76544       };
76545     } catch (std::exception& e) {
76546       {
76547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76548       };
76549     } catch (Dali::DaliException e) {
76550       {
76551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76552       };
76553     } catch (...) {
76554       {
76555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76556       };
76557     }
76558   }
76559
76560   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76561   return jresult;
76562 }
76563
76564
76565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
76566   unsigned int jresult ;
76567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76568   unsigned int result;
76569
76570   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76571   {
76572     try {
76573       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
76574     } catch (std::out_of_range& e) {
76575       {
76576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76577       };
76578     } catch (std::exception& e) {
76579       {
76580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76581       };
76582     } catch (Dali::DaliException e) {
76583       {
76584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76585       };
76586     } catch (...) {
76587       {
76588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76589       };
76590     }
76591   }
76592
76593   jresult = result;
76594   return jresult;
76595 }
76596
76597
76598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
76599   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76600   Dali::Vector2 *arg2 = 0 ;
76601
76602   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76603   arg2 = (Dali::Vector2 *)jarg2;
76604   if (!arg2) {
76605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76606     return ;
76607   }
76608   {
76609     try {
76610       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
76611     } catch (std::out_of_range& e) {
76612       {
76613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76614       };
76615     } catch (std::exception& e) {
76616       {
76617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76618       };
76619     } catch (Dali::DaliException e) {
76620       {
76621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76622       };
76623     } catch (...) {
76624       {
76625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76626       };
76627     }
76628   }
76629
76630 }
76631
76632
76633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
76634   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76635   Dali::Vector2 *arg2 = 0 ;
76636   float arg3 ;
76637
76638   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76639   arg2 = (Dali::Vector2 *)jarg2;
76640   if (!arg2) {
76641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76642     return ;
76643   }
76644   arg3 = (float)jarg3;
76645   {
76646     try {
76647       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
76648     } catch (std::out_of_range& e) {
76649       {
76650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76651       };
76652     } catch (std::exception& e) {
76653       {
76654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76655       };
76656     } catch (Dali::DaliException e) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76659       };
76660     } catch (...) {
76661       {
76662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76663       };
76664     }
76665   }
76666
76667 }
76668
76669
76670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
76671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76672   Dali::Vector2 *arg2 = 0 ;
76673   float arg3 ;
76674   Dali::AlphaFunction arg4 ;
76675   Dali::AlphaFunction *argp4 ;
76676
76677   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76678   arg2 = (Dali::Vector2 *)jarg2;
76679   if (!arg2) {
76680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76681     return ;
76682   }
76683   arg3 = (float)jarg3;
76684   argp4 = (Dali::AlphaFunction *)jarg4;
76685   if (!argp4) {
76686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76687     return ;
76688   }
76689   arg4 = *argp4;
76690   {
76691     try {
76692       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
76693     } catch (std::out_of_range& e) {
76694       {
76695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76696       };
76697     } catch (std::exception& e) {
76698       {
76699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76700       };
76701     } catch (Dali::DaliException e) {
76702       {
76703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76704       };
76705     } catch (...) {
76706       {
76707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76708       };
76709     }
76710   }
76711
76712 }
76713
76714
76715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
76716   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76717   Dali::Vector2 *arg2 = 0 ;
76718   float arg3 ;
76719   Dali::Toolkit::DirectionBias arg4 ;
76720   Dali::Toolkit::DirectionBias arg5 ;
76721
76722   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76723   arg2 = (Dali::Vector2 *)jarg2;
76724   if (!arg2) {
76725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76726     return ;
76727   }
76728   arg3 = (float)jarg3;
76729   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76730   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76731   {
76732     try {
76733       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
76734     } catch (std::out_of_range& e) {
76735       {
76736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76737       };
76738     } catch (std::exception& e) {
76739       {
76740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76741       };
76742     } catch (Dali::DaliException e) {
76743       {
76744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76745       };
76746     } catch (...) {
76747       {
76748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76749       };
76750     }
76751   }
76752
76753 }
76754
76755
76756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
76757   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76758   Dali::Vector2 *arg2 = 0 ;
76759   float arg3 ;
76760   Dali::AlphaFunction arg4 ;
76761   Dali::Toolkit::DirectionBias arg5 ;
76762   Dali::Toolkit::DirectionBias arg6 ;
76763   Dali::AlphaFunction *argp4 ;
76764
76765   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76766   arg2 = (Dali::Vector2 *)jarg2;
76767   if (!arg2) {
76768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76769     return ;
76770   }
76771   arg3 = (float)jarg3;
76772   argp4 = (Dali::AlphaFunction *)jarg4;
76773   if (!argp4) {
76774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76775     return ;
76776   }
76777   arg4 = *argp4;
76778   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76779   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76780   {
76781     try {
76782       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76783     } catch (std::out_of_range& e) {
76784       {
76785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76786       };
76787     } catch (std::exception& e) {
76788       {
76789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76790       };
76791     } catch (Dali::DaliException e) {
76792       {
76793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76794       };
76795     } catch (...) {
76796       {
76797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76798       };
76799     }
76800   }
76801
76802 }
76803
76804
76805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76806   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76807   unsigned int arg2 ;
76808
76809   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76810   arg2 = (unsigned int)jarg2;
76811   {
76812     try {
76813       (arg1)->ScrollTo(arg2);
76814     } catch (std::out_of_range& e) {
76815       {
76816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76817       };
76818     } catch (std::exception& e) {
76819       {
76820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76821       };
76822     } catch (Dali::DaliException e) {
76823       {
76824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76825       };
76826     } catch (...) {
76827       {
76828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76829       };
76830     }
76831   }
76832
76833 }
76834
76835
76836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76837   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76838   unsigned int arg2 ;
76839   float arg3 ;
76840
76841   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76842   arg2 = (unsigned int)jarg2;
76843   arg3 = (float)jarg3;
76844   {
76845     try {
76846       (arg1)->ScrollTo(arg2,arg3);
76847     } catch (std::out_of_range& e) {
76848       {
76849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76850       };
76851     } catch (std::exception& e) {
76852       {
76853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76854       };
76855     } catch (Dali::DaliException e) {
76856       {
76857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76858       };
76859     } catch (...) {
76860       {
76861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76862       };
76863     }
76864   }
76865
76866 }
76867
76868
76869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76870   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76871   unsigned int arg2 ;
76872   float arg3 ;
76873   Dali::Toolkit::DirectionBias arg4 ;
76874
76875   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76876   arg2 = (unsigned int)jarg2;
76877   arg3 = (float)jarg3;
76878   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76879   {
76880     try {
76881       (arg1)->ScrollTo(arg2,arg3,arg4);
76882     } catch (std::out_of_range& e) {
76883       {
76884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76885       };
76886     } catch (std::exception& e) {
76887       {
76888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76889       };
76890     } catch (Dali::DaliException e) {
76891       {
76892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76893       };
76894     } catch (...) {
76895       {
76896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76897       };
76898     }
76899   }
76900
76901 }
76902
76903
76904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76906   Dali::Actor *arg2 = 0 ;
76907
76908   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76909   arg2 = (Dali::Actor *)jarg2;
76910   if (!arg2) {
76911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76912     return ;
76913   }
76914   {
76915     try {
76916       (arg1)->ScrollTo(*arg2);
76917     } catch (std::out_of_range& e) {
76918       {
76919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76920       };
76921     } catch (std::exception& e) {
76922       {
76923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76924       };
76925     } catch (Dali::DaliException e) {
76926       {
76927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76928       };
76929     } catch (...) {
76930       {
76931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76932       };
76933     }
76934   }
76935
76936 }
76937
76938
76939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76940   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76941   Dali::Actor *arg2 = 0 ;
76942   float arg3 ;
76943
76944   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76945   arg2 = (Dali::Actor *)jarg2;
76946   if (!arg2) {
76947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76948     return ;
76949   }
76950   arg3 = (float)jarg3;
76951   {
76952     try {
76953       (arg1)->ScrollTo(*arg2,arg3);
76954     } catch (std::out_of_range& e) {
76955       {
76956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76957       };
76958     } catch (std::exception& e) {
76959       {
76960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76961       };
76962     } catch (Dali::DaliException e) {
76963       {
76964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76965       };
76966     } catch (...) {
76967       {
76968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76969       };
76970     }
76971   }
76972
76973 }
76974
76975
76976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76977   unsigned int jresult ;
76978   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76979   bool result;
76980
76981   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76982   {
76983     try {
76984       result = (bool)(arg1)->ScrollToSnapPoint();
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 = result;
77005   return jresult;
77006 }
77007
77008
77009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
77010   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77011   Dali::Constraint arg2 ;
77012   Dali::Constraint *argp2 ;
77013
77014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77015   argp2 = (Dali::Constraint *)jarg2;
77016   if (!argp2) {
77017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
77018     return ;
77019   }
77020   arg2 = *argp2;
77021   {
77022     try {
77023       (arg1)->ApplyConstraintToChildren(arg2);
77024     } catch (std::out_of_range& e) {
77025       {
77026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77027       };
77028     } catch (std::exception& e) {
77029       {
77030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77031       };
77032     } catch (Dali::DaliException e) {
77033       {
77034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77035       };
77036     } catch (...) {
77037       {
77038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77039       };
77040     }
77041   }
77042
77043 }
77044
77045
77046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
77047   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77048
77049   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77050   {
77051     try {
77052       (arg1)->RemoveConstraintsFromChildren();
77053     } catch (std::out_of_range& e) {
77054       {
77055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77056       };
77057     } catch (std::exception& e) {
77058       {
77059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77060       };
77061     } catch (Dali::DaliException e) {
77062       {
77063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77064       };
77065     } catch (...) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77068       };
77069     }
77070   }
77071
77072 }
77073
77074
77075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
77076   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77077   Dali::Toolkit::ScrollViewEffect arg2 ;
77078   Dali::Toolkit::ScrollViewEffect *argp2 ;
77079
77080   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77081   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
77082   if (!argp2) {
77083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
77084     return ;
77085   }
77086   arg2 = *argp2;
77087   {
77088     try {
77089       (arg1)->ApplyEffect(arg2);
77090     } catch (std::out_of_range& e) {
77091       {
77092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77093       };
77094     } catch (std::exception& e) {
77095       {
77096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77097       };
77098     } catch (Dali::DaliException e) {
77099       {
77100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77101       };
77102     } catch (...) {
77103       {
77104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77105       };
77106     }
77107   }
77108
77109 }
77110
77111
77112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
77113   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77114   Dali::Toolkit::ScrollViewEffect arg2 ;
77115   Dali::Toolkit::ScrollViewEffect *argp2 ;
77116
77117   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77118   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
77119   if (!argp2) {
77120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
77121     return ;
77122   }
77123   arg2 = *argp2;
77124   {
77125     try {
77126       (arg1)->RemoveEffect(arg2);
77127     } catch (std::out_of_range& e) {
77128       {
77129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77130       };
77131     } catch (std::exception& e) {
77132       {
77133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77134       };
77135     } catch (Dali::DaliException e) {
77136       {
77137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77138       };
77139     } catch (...) {
77140       {
77141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77142       };
77143     }
77144   }
77145
77146 }
77147
77148
77149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
77150   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77151
77152   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77153   {
77154     try {
77155       (arg1)->RemoveAllEffects();
77156     } catch (std::out_of_range& e) {
77157       {
77158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77159       };
77160     } catch (std::exception& e) {
77161       {
77162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77163       };
77164     } catch (Dali::DaliException e) {
77165       {
77166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77167       };
77168     } catch (...) {
77169       {
77170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77171       };
77172     }
77173   }
77174
77175 }
77176
77177
77178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
77179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77180   Dali::Actor arg2 ;
77181   Dali::Actor *argp2 ;
77182
77183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77184   argp2 = (Dali::Actor *)jarg2;
77185   if (!argp2) {
77186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77187     return ;
77188   }
77189   arg2 = *argp2;
77190   {
77191     try {
77192       (arg1)->BindActor(arg2);
77193     } catch (std::out_of_range& e) {
77194       {
77195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77196       };
77197     } catch (std::exception& e) {
77198       {
77199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77200       };
77201     } catch (Dali::DaliException e) {
77202       {
77203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77204       };
77205     } catch (...) {
77206       {
77207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77208       };
77209     }
77210   }
77211
77212 }
77213
77214
77215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
77216   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77217   Dali::Actor arg2 ;
77218   Dali::Actor *argp2 ;
77219
77220   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77221   argp2 = (Dali::Actor *)jarg2;
77222   if (!argp2) {
77223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77224     return ;
77225   }
77226   arg2 = *argp2;
77227   {
77228     try {
77229       (arg1)->UnbindActor(arg2);
77230     } catch (std::out_of_range& e) {
77231       {
77232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77233       };
77234     } catch (std::exception& e) {
77235       {
77236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77237       };
77238     } catch (Dali::DaliException e) {
77239       {
77240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77241       };
77242     } catch (...) {
77243       {
77244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77245       };
77246     }
77247   }
77248
77249 }
77250
77251
77252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
77253   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77254   Dali::Radian arg2 ;
77255   Dali::Radian arg3 ;
77256   Dali::Radian *argp2 ;
77257   Dali::Radian *argp3 ;
77258
77259   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77260   argp2 = (Dali::Radian *)jarg2;
77261   if (!argp2) {
77262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
77263     return ;
77264   }
77265   arg2 = *argp2;
77266   argp3 = (Dali::Radian *)jarg3;
77267   if (!argp3) {
77268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
77269     return ;
77270   }
77271   arg3 = *argp3;
77272   {
77273     try {
77274       (arg1)->SetScrollingDirection(arg2,arg3);
77275     } catch (std::out_of_range& e) {
77276       {
77277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77278       };
77279     } catch (std::exception& e) {
77280       {
77281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77282       };
77283     } catch (Dali::DaliException e) {
77284       {
77285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77286       };
77287     } catch (...) {
77288       {
77289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77290       };
77291     }
77292   }
77293
77294 }
77295
77296
77297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
77298   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77299   Dali::Radian arg2 ;
77300   Dali::Radian *argp2 ;
77301
77302   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77303   argp2 = (Dali::Radian *)jarg2;
77304   if (!argp2) {
77305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
77306     return ;
77307   }
77308   arg2 = *argp2;
77309   {
77310     try {
77311       (arg1)->SetScrollingDirection(arg2);
77312     } catch (std::out_of_range& e) {
77313       {
77314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77315       };
77316     } catch (std::exception& e) {
77317       {
77318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77319       };
77320     } catch (Dali::DaliException e) {
77321       {
77322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77323       };
77324     } catch (...) {
77325       {
77326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77327       };
77328     }
77329   }
77330
77331 }
77332
77333
77334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
77335   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77336   Dali::Radian arg2 ;
77337   Dali::Radian *argp2 ;
77338
77339   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77340   argp2 = (Dali::Radian *)jarg2;
77341   if (!argp2) {
77342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
77343     return ;
77344   }
77345   arg2 = *argp2;
77346   {
77347     try {
77348       (arg1)->RemoveScrollingDirection(arg2);
77349     } catch (std::out_of_range& e) {
77350       {
77351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77352       };
77353     } catch (std::exception& e) {
77354       {
77355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77356       };
77357     } catch (Dali::DaliException e) {
77358       {
77359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77360       };
77361     } catch (...) {
77362       {
77363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77364       };
77365     }
77366   }
77367
77368 }
77369
77370
77371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
77372   void * jresult ;
77373   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77374   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
77375
77376   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77377   {
77378     try {
77379       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
77380     } catch (std::out_of_range& e) {
77381       {
77382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77383       };
77384     } catch (std::exception& e) {
77385       {
77386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77387       };
77388     } catch (Dali::DaliException e) {
77389       {
77390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77391       };
77392     } catch (...) {
77393       {
77394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77395       };
77396     }
77397   }
77398
77399   jresult = (void *)result;
77400   return jresult;
77401 }
77402
77403
77404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
77405   int jresult ;
77406   int result;
77407
77408   result = (int)Dali::Toolkit::TableView::Property::ROWS;
77409   jresult = (int)result;
77410   return jresult;
77411 }
77412
77413
77414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
77415   int jresult ;
77416   int result;
77417
77418   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
77419   jresult = (int)result;
77420   return jresult;
77421 }
77422
77423
77424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
77425   int jresult ;
77426   int result;
77427
77428   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
77429   jresult = (int)result;
77430   return jresult;
77431 }
77432
77433
77434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
77435   int jresult ;
77436   int result;
77437
77438   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
77439   jresult = (int)result;
77440   return jresult;
77441 }
77442
77443
77444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
77445   int jresult ;
77446   int result;
77447
77448   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
77449   jresult = (int)result;
77450   return jresult;
77451 }
77452
77453
77454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
77455   void * jresult ;
77456   Dali::Toolkit::TableView::Property *result = 0 ;
77457
77458   {
77459     try {
77460       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
77461     } catch (std::out_of_range& e) {
77462       {
77463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77464       };
77465     } catch (std::exception& e) {
77466       {
77467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77468       };
77469     } catch (Dali::DaliException e) {
77470       {
77471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77472       };
77473     } catch (...) {
77474       {
77475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77476       };
77477     }
77478   }
77479
77480   jresult = (void *)result;
77481   return jresult;
77482 }
77483
77484
77485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
77486   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
77487
77488   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
77489   {
77490     try {
77491       delete arg1;
77492     } catch (std::out_of_range& e) {
77493       {
77494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77495       };
77496     } catch (std::exception& e) {
77497       {
77498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77499       };
77500     } catch (Dali::DaliException e) {
77501       {
77502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77503       };
77504     } catch (...) {
77505       {
77506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77507       };
77508     }
77509   }
77510
77511 }
77512
77513
77514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
77515   int jresult ;
77516   int result;
77517
77518   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
77519   jresult = (int)result;
77520   return jresult;
77521 }
77522
77523
77524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
77525   int jresult ;
77526   int result;
77527
77528   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
77529   jresult = (int)result;
77530   return jresult;
77531 }
77532
77533
77534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
77535   int jresult ;
77536   int result;
77537
77538   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
77539   jresult = (int)result;
77540   return jresult;
77541 }
77542
77543
77544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
77545   int jresult ;
77546   int result;
77547
77548   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
77549   jresult = (int)result;
77550   return jresult;
77551 }
77552
77553
77554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
77555   int jresult ;
77556   int result;
77557
77558   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
77559   jresult = (int)result;
77560   return jresult;
77561 }
77562
77563
77564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
77565   void * jresult ;
77566   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
77567
77568   {
77569     try {
77570       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
77571     } catch (std::out_of_range& e) {
77572       {
77573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77574       };
77575     } catch (std::exception& e) {
77576       {
77577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77578       };
77579     } catch (Dali::DaliException e) {
77580       {
77581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77582       };
77583     } catch (...) {
77584       {
77585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77586       };
77587     }
77588   }
77589
77590   jresult = (void *)result;
77591   return jresult;
77592 }
77593
77594
77595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
77596   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
77597
77598   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
77599   {
77600     try {
77601       delete arg1;
77602     } catch (std::out_of_range& e) {
77603       {
77604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77605       };
77606     } catch (std::exception& e) {
77607       {
77608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77609       };
77610     } catch (Dali::DaliException e) {
77611       {
77612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77613       };
77614     } catch (...) {
77615       {
77616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77617       };
77618     }
77619   }
77620
77621 }
77622
77623
77624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
77625   void * jresult ;
77626   unsigned int arg1 ;
77627   unsigned int arg2 ;
77628   unsigned int arg3 ;
77629   unsigned int arg4 ;
77630   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77631
77632   arg1 = (unsigned int)jarg1;
77633   arg2 = (unsigned int)jarg2;
77634   arg3 = (unsigned int)jarg3;
77635   arg4 = (unsigned int)jarg4;
77636   {
77637     try {
77638       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
77639     } catch (std::out_of_range& e) {
77640       {
77641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77642       };
77643     } catch (std::exception& e) {
77644       {
77645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77646       };
77647     } catch (Dali::DaliException e) {
77648       {
77649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77650       };
77651     } catch (...) {
77652       {
77653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77654       };
77655     }
77656   }
77657
77658   jresult = (void *)result;
77659   return jresult;
77660 }
77661
77662
77663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
77664   void * jresult ;
77665   unsigned int arg1 ;
77666   unsigned int arg2 ;
77667   unsigned int arg3 ;
77668   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77669
77670   arg1 = (unsigned int)jarg1;
77671   arg2 = (unsigned int)jarg2;
77672   arg3 = (unsigned int)jarg3;
77673   {
77674     try {
77675       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
77676     } catch (std::out_of_range& e) {
77677       {
77678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77679       };
77680     } catch (std::exception& e) {
77681       {
77682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77683       };
77684     } catch (Dali::DaliException e) {
77685       {
77686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77687       };
77688     } catch (...) {
77689       {
77690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77691       };
77692     }
77693   }
77694
77695   jresult = (void *)result;
77696   return jresult;
77697 }
77698
77699
77700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
77701   void * jresult ;
77702   unsigned int arg1 ;
77703   unsigned int arg2 ;
77704   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77705
77706   arg1 = (unsigned int)jarg1;
77707   arg2 = (unsigned int)jarg2;
77708   {
77709     try {
77710       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
77711     } catch (std::out_of_range& e) {
77712       {
77713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77714       };
77715     } catch (std::exception& e) {
77716       {
77717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77718       };
77719     } catch (Dali::DaliException e) {
77720       {
77721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77722       };
77723     } catch (...) {
77724       {
77725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77726       };
77727     }
77728   }
77729
77730   jresult = (void *)result;
77731   return jresult;
77732 }
77733
77734
77735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
77736   void * jresult ;
77737   unsigned int arg1 ;
77738   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77739
77740   arg1 = (unsigned int)jarg1;
77741   {
77742     try {
77743       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
77744     } catch (std::out_of_range& e) {
77745       {
77746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77747       };
77748     } catch (std::exception& e) {
77749       {
77750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77751       };
77752     } catch (Dali::DaliException e) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77755       };
77756     } catch (...) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77759       };
77760     }
77761   }
77762
77763   jresult = (void *)result;
77764   return jresult;
77765 }
77766
77767
77768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77769   void * jresult ;
77770   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77771
77772   {
77773     try {
77774       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77775     } catch (std::out_of_range& e) {
77776       {
77777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77778       };
77779     } catch (std::exception& e) {
77780       {
77781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77782       };
77783     } catch (Dali::DaliException e) {
77784       {
77785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77786       };
77787     } catch (...) {
77788       {
77789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77790       };
77791     }
77792   }
77793
77794   jresult = (void *)result;
77795   return jresult;
77796 }
77797
77798
77799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77800   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77801   unsigned int arg2 ;
77802
77803   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77804   arg2 = (unsigned int)jarg2;
77805   if (arg1) (arg1)->rowIndex = arg2;
77806 }
77807
77808
77809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77810   unsigned int jresult ;
77811   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77812   unsigned int result;
77813
77814   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77815   result = (unsigned int) ((arg1)->rowIndex);
77816   jresult = result;
77817   return jresult;
77818 }
77819
77820
77821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77822   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77823   unsigned int arg2 ;
77824
77825   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77826   arg2 = (unsigned int)jarg2;
77827   if (arg1) (arg1)->columnIndex = arg2;
77828 }
77829
77830
77831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77832   unsigned int jresult ;
77833   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77834   unsigned int result;
77835
77836   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77837   result = (unsigned int) ((arg1)->columnIndex);
77838   jresult = result;
77839   return jresult;
77840 }
77841
77842
77843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77844   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77845   unsigned int arg2 ;
77846
77847   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77848   arg2 = (unsigned int)jarg2;
77849   if (arg1) (arg1)->rowSpan = arg2;
77850 }
77851
77852
77853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77854   unsigned int jresult ;
77855   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77856   unsigned int result;
77857
77858   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77859   result = (unsigned int) ((arg1)->rowSpan);
77860   jresult = result;
77861   return jresult;
77862 }
77863
77864
77865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77866   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77867   unsigned int arg2 ;
77868
77869   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77870   arg2 = (unsigned int)jarg2;
77871   if (arg1) (arg1)->columnSpan = arg2;
77872 }
77873
77874
77875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77876   unsigned int jresult ;
77877   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77878   unsigned int result;
77879
77880   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77881   result = (unsigned int) ((arg1)->columnSpan);
77882   jresult = result;
77883   return jresult;
77884 }
77885
77886
77887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77888   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77889
77890   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77891   {
77892     try {
77893       delete arg1;
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_new_TableView__SWIG_0() {
77917   void * jresult ;
77918   Dali::Toolkit::TableView *result = 0 ;
77919
77920   {
77921     try {
77922       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77923     } catch (std::out_of_range& e) {
77924       {
77925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77926       };
77927     } catch (std::exception& e) {
77928       {
77929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77930       };
77931     } catch (Dali::DaliException e) {
77932       {
77933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77934       };
77935     } catch (...) {
77936       {
77937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77938       };
77939     }
77940   }
77941
77942   jresult = (void *)result;
77943   return jresult;
77944 }
77945
77946
77947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77948   void * jresult ;
77949   Dali::Toolkit::TableView *arg1 = 0 ;
77950   Dali::Toolkit::TableView *result = 0 ;
77951
77952   arg1 = (Dali::Toolkit::TableView *)jarg1;
77953   if (!arg1) {
77954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77955     return 0;
77956   }
77957   {
77958     try {
77959       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77960     } catch (std::out_of_range& e) {
77961       {
77962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77963       };
77964     } catch (std::exception& e) {
77965       {
77966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77967       };
77968     } catch (Dali::DaliException e) {
77969       {
77970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77971       };
77972     } catch (...) {
77973       {
77974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77975       };
77976     }
77977   }
77978
77979   jresult = (void *)result;
77980   return jresult;
77981 }
77982
77983
77984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77985   void * jresult ;
77986   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77987   Dali::Toolkit::TableView *arg2 = 0 ;
77988   Dali::Toolkit::TableView *result = 0 ;
77989
77990   arg1 = (Dali::Toolkit::TableView *)jarg1;
77991   arg2 = (Dali::Toolkit::TableView *)jarg2;
77992   if (!arg2) {
77993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77994     return 0;
77995   }
77996   {
77997     try {
77998       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77999     } catch (std::out_of_range& e) {
78000       {
78001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78002       };
78003     } catch (std::exception& e) {
78004       {
78005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78006       };
78007     } catch (Dali::DaliException e) {
78008       {
78009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78010       };
78011     } catch (...) {
78012       {
78013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78014       };
78015     }
78016   }
78017
78018   jresult = (void *)result;
78019   return jresult;
78020 }
78021
78022
78023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
78024   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78025
78026   arg1 = (Dali::Toolkit::TableView *)jarg1;
78027   {
78028     try {
78029       delete arg1;
78030     } catch (std::out_of_range& e) {
78031       {
78032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78033       };
78034     } catch (std::exception& e) {
78035       {
78036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78037       };
78038     } catch (Dali::DaliException e) {
78039       {
78040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78041       };
78042     } catch (...) {
78043       {
78044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78045       };
78046     }
78047   }
78048
78049 }
78050
78051
78052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
78053   void * jresult ;
78054   unsigned int arg1 ;
78055   unsigned int arg2 ;
78056   Dali::Toolkit::TableView result;
78057
78058   arg1 = (unsigned int)jarg1;
78059   arg2 = (unsigned int)jarg2;
78060   {
78061     try {
78062       result = Dali::Toolkit::TableView::New(arg1,arg2);
78063     } catch (std::out_of_range& e) {
78064       {
78065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78066       };
78067     } catch (std::exception& e) {
78068       {
78069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78070       };
78071     } catch (Dali::DaliException e) {
78072       {
78073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78074       };
78075     } catch (...) {
78076       {
78077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78078       };
78079     }
78080   }
78081
78082   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
78083   return jresult;
78084 }
78085
78086
78087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
78088   void * jresult ;
78089   Dali::BaseHandle arg1 ;
78090   Dali::BaseHandle *argp1 ;
78091   Dali::Toolkit::TableView result;
78092
78093   argp1 = (Dali::BaseHandle *)jarg1;
78094   if (!argp1) {
78095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78096     return 0;
78097   }
78098   arg1 = *argp1;
78099   {
78100     try {
78101       result = Dali::Toolkit::TableView::DownCast(arg1);
78102     } catch (std::out_of_range& e) {
78103       {
78104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78105       };
78106     } catch (std::exception& e) {
78107       {
78108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78109       };
78110     } catch (Dali::DaliException e) {
78111       {
78112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78113       };
78114     } catch (...) {
78115       {
78116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78117       };
78118     }
78119   }
78120
78121   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
78122   return jresult;
78123 }
78124
78125
78126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
78127   unsigned int jresult ;
78128   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78129   Dali::Actor arg2 ;
78130   Dali::Toolkit::TableView::CellPosition arg3 ;
78131   Dali::Actor *argp2 ;
78132   Dali::Toolkit::TableView::CellPosition *argp3 ;
78133   bool result;
78134
78135   arg1 = (Dali::Toolkit::TableView *)jarg1;
78136   argp2 = (Dali::Actor *)jarg2;
78137   if (!argp2) {
78138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78139     return 0;
78140   }
78141   arg2 = *argp2;
78142   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
78143   if (!argp3) {
78144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78145     return 0;
78146   }
78147   arg3 = *argp3;
78148   {
78149     try {
78150       result = (bool)(arg1)->AddChild(arg2,arg3);
78151     } catch (std::out_of_range& e) {
78152       {
78153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78154       };
78155     } catch (std::exception& e) {
78156       {
78157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78158       };
78159     } catch (Dali::DaliException e) {
78160       {
78161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78162       };
78163     } catch (...) {
78164       {
78165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78166       };
78167     }
78168   }
78169
78170   jresult = result;
78171   return jresult;
78172 }
78173
78174
78175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
78176   void * jresult ;
78177   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78178   Dali::Toolkit::TableView::CellPosition arg2 ;
78179   Dali::Toolkit::TableView::CellPosition *argp2 ;
78180   Dali::Actor result;
78181
78182   arg1 = (Dali::Toolkit::TableView *)jarg1;
78183   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78184   if (!argp2) {
78185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78186     return 0;
78187   }
78188   arg2 = *argp2;
78189   {
78190     try {
78191       result = (arg1)->GetChildAt(arg2);
78192     } catch (std::out_of_range& e) {
78193       {
78194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78195       };
78196     } catch (std::exception& e) {
78197       {
78198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78199       };
78200     } catch (Dali::DaliException e) {
78201       {
78202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78203       };
78204     } catch (...) {
78205       {
78206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78207       };
78208     }
78209   }
78210
78211   jresult = new Dali::Actor((const Dali::Actor &)result);
78212   return jresult;
78213 }
78214
78215
78216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
78217   void * jresult ;
78218   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78219   Dali::Toolkit::TableView::CellPosition arg2 ;
78220   Dali::Toolkit::TableView::CellPosition *argp2 ;
78221   Dali::Actor result;
78222
78223   arg1 = (Dali::Toolkit::TableView *)jarg1;
78224   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78225   if (!argp2) {
78226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78227     return 0;
78228   }
78229   arg2 = *argp2;
78230   {
78231     try {
78232       result = (arg1)->RemoveChildAt(arg2);
78233     } catch (std::out_of_range& e) {
78234       {
78235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78236       };
78237     } catch (std::exception& e) {
78238       {
78239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78240       };
78241     } catch (Dali::DaliException e) {
78242       {
78243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78244       };
78245     } catch (...) {
78246       {
78247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78248       };
78249     }
78250   }
78251
78252   jresult = new Dali::Actor((const Dali::Actor &)result);
78253   return jresult;
78254 }
78255
78256
78257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
78258   unsigned int jresult ;
78259   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78260   Dali::Actor arg2 ;
78261   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
78262   Dali::Actor *argp2 ;
78263   bool result;
78264
78265   arg1 = (Dali::Toolkit::TableView *)jarg1;
78266   argp2 = (Dali::Actor *)jarg2;
78267   if (!argp2) {
78268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78269     return 0;
78270   }
78271   arg2 = *argp2;
78272   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
78273   if (!arg3) {
78274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
78275     return 0;
78276   }
78277   {
78278     try {
78279       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
78280     } catch (std::out_of_range& e) {
78281       {
78282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78283       };
78284     } catch (std::exception& e) {
78285       {
78286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78287       };
78288     } catch (Dali::DaliException e) {
78289       {
78290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78291       };
78292     } catch (...) {
78293       {
78294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78295       };
78296     }
78297   }
78298
78299   jresult = result;
78300   return jresult;
78301 }
78302
78303
78304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
78305   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78306   unsigned int arg2 ;
78307
78308   arg1 = (Dali::Toolkit::TableView *)jarg1;
78309   arg2 = (unsigned int)jarg2;
78310   {
78311     try {
78312       (arg1)->InsertRow(arg2);
78313     } catch (std::out_of_range& e) {
78314       {
78315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78316       };
78317     } catch (std::exception& e) {
78318       {
78319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78320       };
78321     } catch (Dali::DaliException e) {
78322       {
78323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78324       };
78325     } catch (...) {
78326       {
78327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78328       };
78329     }
78330   }
78331
78332 }
78333
78334
78335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
78336   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78337   unsigned int arg2 ;
78338
78339   arg1 = (Dali::Toolkit::TableView *)jarg1;
78340   arg2 = (unsigned int)jarg2;
78341   {
78342     try {
78343       (arg1)->DeleteRow(arg2);
78344     } catch (std::out_of_range& e) {
78345       {
78346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78347       };
78348     } catch (std::exception& e) {
78349       {
78350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78351       };
78352     } catch (Dali::DaliException e) {
78353       {
78354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78355       };
78356     } catch (...) {
78357       {
78358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78359       };
78360     }
78361   }
78362
78363 }
78364
78365
78366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
78367   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78368   unsigned int arg2 ;
78369   std::vector< Dali::Actor > *arg3 = 0 ;
78370
78371   arg1 = (Dali::Toolkit::TableView *)jarg1;
78372   arg2 = (unsigned int)jarg2;
78373   arg3 = (std::vector< Dali::Actor > *)jarg3;
78374   if (!arg3) {
78375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78376     return ;
78377   }
78378   {
78379     try {
78380       (arg1)->DeleteRow(arg2,*arg3);
78381     } catch (std::out_of_range& e) {
78382       {
78383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78384       };
78385     } catch (std::exception& e) {
78386       {
78387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78388       };
78389     } catch (Dali::DaliException e) {
78390       {
78391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78392       };
78393     } catch (...) {
78394       {
78395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78396       };
78397     }
78398   }
78399
78400 }
78401
78402
78403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
78404   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78405   unsigned int arg2 ;
78406
78407   arg1 = (Dali::Toolkit::TableView *)jarg1;
78408   arg2 = (unsigned int)jarg2;
78409   {
78410     try {
78411       (arg1)->InsertColumn(arg2);
78412     } catch (std::out_of_range& e) {
78413       {
78414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78415       };
78416     } catch (std::exception& e) {
78417       {
78418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78419       };
78420     } catch (Dali::DaliException e) {
78421       {
78422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78423       };
78424     } catch (...) {
78425       {
78426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78427       };
78428     }
78429   }
78430
78431 }
78432
78433
78434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
78435   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78436   unsigned int arg2 ;
78437
78438   arg1 = (Dali::Toolkit::TableView *)jarg1;
78439   arg2 = (unsigned int)jarg2;
78440   {
78441     try {
78442       (arg1)->DeleteColumn(arg2);
78443     } catch (std::out_of_range& e) {
78444       {
78445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78446       };
78447     } catch (std::exception& e) {
78448       {
78449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78450       };
78451     } catch (Dali::DaliException e) {
78452       {
78453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78454       };
78455     } catch (...) {
78456       {
78457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78458       };
78459     }
78460   }
78461
78462 }
78463
78464
78465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
78466   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78467   unsigned int arg2 ;
78468   std::vector< Dali::Actor > *arg3 = 0 ;
78469
78470   arg1 = (Dali::Toolkit::TableView *)jarg1;
78471   arg2 = (unsigned int)jarg2;
78472   arg3 = (std::vector< Dali::Actor > *)jarg3;
78473   if (!arg3) {
78474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78475     return ;
78476   }
78477   {
78478     try {
78479       (arg1)->DeleteColumn(arg2,*arg3);
78480     } catch (std::out_of_range& e) {
78481       {
78482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78483       };
78484     } catch (std::exception& e) {
78485       {
78486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78487       };
78488     } catch (Dali::DaliException e) {
78489       {
78490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78491       };
78492     } catch (...) {
78493       {
78494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78495       };
78496     }
78497   }
78498
78499 }
78500
78501
78502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
78503   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78504   unsigned int arg2 ;
78505   unsigned int arg3 ;
78506
78507   arg1 = (Dali::Toolkit::TableView *)jarg1;
78508   arg2 = (unsigned int)jarg2;
78509   arg3 = (unsigned int)jarg3;
78510   {
78511     try {
78512       (arg1)->Resize(arg2,arg3);
78513     } catch (std::out_of_range& e) {
78514       {
78515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78516       };
78517     } catch (std::exception& e) {
78518       {
78519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78520       };
78521     } catch (Dali::DaliException e) {
78522       {
78523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78524       };
78525     } catch (...) {
78526       {
78527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78528       };
78529     }
78530   }
78531
78532 }
78533
78534
78535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
78536   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78537   unsigned int arg2 ;
78538   unsigned int arg3 ;
78539   std::vector< Dali::Actor > *arg4 = 0 ;
78540
78541   arg1 = (Dali::Toolkit::TableView *)jarg1;
78542   arg2 = (unsigned int)jarg2;
78543   arg3 = (unsigned int)jarg3;
78544   arg4 = (std::vector< Dali::Actor > *)jarg4;
78545   if (!arg4) {
78546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78547     return ;
78548   }
78549   {
78550     try {
78551       (arg1)->Resize(arg2,arg3,*arg4);
78552     } catch (std::out_of_range& e) {
78553       {
78554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78555       };
78556     } catch (std::exception& e) {
78557       {
78558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78559       };
78560     } catch (Dali::DaliException e) {
78561       {
78562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78563       };
78564     } catch (...) {
78565       {
78566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78567       };
78568     }
78569   }
78570
78571 }
78572
78573
78574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
78575   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78576   Dali::Size arg2 ;
78577   Dali::Size *argp2 ;
78578
78579   arg1 = (Dali::Toolkit::TableView *)jarg1;
78580   argp2 = (Dali::Size *)jarg2;
78581   if (!argp2) {
78582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78583     return ;
78584   }
78585   arg2 = *argp2;
78586   {
78587     try {
78588       (arg1)->SetCellPadding(arg2);
78589     } catch (std::out_of_range& e) {
78590       {
78591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78592       };
78593     } catch (std::exception& e) {
78594       {
78595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78596       };
78597     } catch (Dali::DaliException e) {
78598       {
78599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78600       };
78601     } catch (...) {
78602       {
78603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78604       };
78605     }
78606   }
78607
78608 }
78609
78610
78611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
78612   void * jresult ;
78613   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78614   Dali::Size result;
78615
78616   arg1 = (Dali::Toolkit::TableView *)jarg1;
78617   {
78618     try {
78619       result = (arg1)->GetCellPadding();
78620     } catch (std::out_of_range& e) {
78621       {
78622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78623       };
78624     } catch (std::exception& e) {
78625       {
78626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78627       };
78628     } catch (Dali::DaliException e) {
78629       {
78630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78631       };
78632     } catch (...) {
78633       {
78634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78635       };
78636     }
78637   }
78638
78639   jresult = new Dali::Size((const Dali::Size &)result);
78640   return jresult;
78641 }
78642
78643
78644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
78645   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78646   unsigned int arg2 ;
78647
78648   arg1 = (Dali::Toolkit::TableView *)jarg1;
78649   arg2 = (unsigned int)jarg2;
78650   {
78651     try {
78652       (arg1)->SetFitHeight(arg2);
78653     } catch (std::out_of_range& e) {
78654       {
78655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78656       };
78657     } catch (std::exception& e) {
78658       {
78659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78660       };
78661     } catch (Dali::DaliException e) {
78662       {
78663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78664       };
78665     } catch (...) {
78666       {
78667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78668       };
78669     }
78670   }
78671
78672 }
78673
78674
78675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
78676   unsigned int jresult ;
78677   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78678   unsigned int arg2 ;
78679   bool result;
78680
78681   arg1 = (Dali::Toolkit::TableView *)jarg1;
78682   arg2 = (unsigned int)jarg2;
78683   {
78684     try {
78685       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
78686     } catch (std::out_of_range& e) {
78687       {
78688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78689       };
78690     } catch (std::exception& e) {
78691       {
78692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78693       };
78694     } catch (Dali::DaliException e) {
78695       {
78696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78697       };
78698     } catch (...) {
78699       {
78700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78701       };
78702     }
78703   }
78704
78705   jresult = result;
78706   return jresult;
78707 }
78708
78709
78710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
78711   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78712   unsigned int arg2 ;
78713
78714   arg1 = (Dali::Toolkit::TableView *)jarg1;
78715   arg2 = (unsigned int)jarg2;
78716   {
78717     try {
78718       (arg1)->SetFitWidth(arg2);
78719     } catch (std::out_of_range& e) {
78720       {
78721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78722       };
78723     } catch (std::exception& e) {
78724       {
78725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78726       };
78727     } catch (Dali::DaliException e) {
78728       {
78729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78730       };
78731     } catch (...) {
78732       {
78733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78734       };
78735     }
78736   }
78737
78738 }
78739
78740
78741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
78742   unsigned int jresult ;
78743   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78744   unsigned int arg2 ;
78745   bool result;
78746
78747   arg1 = (Dali::Toolkit::TableView *)jarg1;
78748   arg2 = (unsigned int)jarg2;
78749   {
78750     try {
78751       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
78752     } catch (std::out_of_range& e) {
78753       {
78754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78755       };
78756     } catch (std::exception& e) {
78757       {
78758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78759       };
78760     } catch (Dali::DaliException e) {
78761       {
78762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78763       };
78764     } catch (...) {
78765       {
78766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78767       };
78768     }
78769   }
78770
78771   jresult = result;
78772   return jresult;
78773 }
78774
78775
78776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78777   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78778   unsigned int arg2 ;
78779   float arg3 ;
78780
78781   arg1 = (Dali::Toolkit::TableView *)jarg1;
78782   arg2 = (unsigned int)jarg2;
78783   arg3 = (float)jarg3;
78784   {
78785     try {
78786       (arg1)->SetFixedHeight(arg2,arg3);
78787     } catch (std::out_of_range& e) {
78788       {
78789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78790       };
78791     } catch (std::exception& e) {
78792       {
78793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78794       };
78795     } catch (Dali::DaliException e) {
78796       {
78797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78798       };
78799     } catch (...) {
78800       {
78801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78802       };
78803     }
78804   }
78805
78806 }
78807
78808
78809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78810   float jresult ;
78811   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78812   unsigned int arg2 ;
78813   float result;
78814
78815   arg1 = (Dali::Toolkit::TableView *)jarg1;
78816   arg2 = (unsigned int)jarg2;
78817   {
78818     try {
78819       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78820     } catch (std::out_of_range& e) {
78821       {
78822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78823       };
78824     } catch (std::exception& e) {
78825       {
78826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78827       };
78828     } catch (Dali::DaliException e) {
78829       {
78830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78831       };
78832     } catch (...) {
78833       {
78834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78835       };
78836     }
78837   }
78838
78839   jresult = result;
78840   return jresult;
78841 }
78842
78843
78844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78845   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78846   unsigned int arg2 ;
78847   float arg3 ;
78848
78849   arg1 = (Dali::Toolkit::TableView *)jarg1;
78850   arg2 = (unsigned int)jarg2;
78851   arg3 = (float)jarg3;
78852   {
78853     try {
78854       (arg1)->SetRelativeHeight(arg2,arg3);
78855     } catch (std::out_of_range& e) {
78856       {
78857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78858       };
78859     } catch (std::exception& e) {
78860       {
78861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78862       };
78863     } catch (Dali::DaliException e) {
78864       {
78865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78866       };
78867     } catch (...) {
78868       {
78869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78870       };
78871     }
78872   }
78873
78874 }
78875
78876
78877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78878   float jresult ;
78879   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78880   unsigned int arg2 ;
78881   float result;
78882
78883   arg1 = (Dali::Toolkit::TableView *)jarg1;
78884   arg2 = (unsigned int)jarg2;
78885   {
78886     try {
78887       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78888     } catch (std::out_of_range& e) {
78889       {
78890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78891       };
78892     } catch (std::exception& e) {
78893       {
78894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78895       };
78896     } catch (Dali::DaliException e) {
78897       {
78898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78899       };
78900     } catch (...) {
78901       {
78902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78903       };
78904     }
78905   }
78906
78907   jresult = result;
78908   return jresult;
78909 }
78910
78911
78912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78913   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78914   unsigned int arg2 ;
78915   float arg3 ;
78916
78917   arg1 = (Dali::Toolkit::TableView *)jarg1;
78918   arg2 = (unsigned int)jarg2;
78919   arg3 = (float)jarg3;
78920   {
78921     try {
78922       (arg1)->SetFixedWidth(arg2,arg3);
78923     } catch (std::out_of_range& e) {
78924       {
78925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78926       };
78927     } catch (std::exception& e) {
78928       {
78929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78930       };
78931     } catch (Dali::DaliException e) {
78932       {
78933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78934       };
78935     } catch (...) {
78936       {
78937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78938       };
78939     }
78940   }
78941
78942 }
78943
78944
78945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78946   float jresult ;
78947   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78948   unsigned int arg2 ;
78949   float result;
78950
78951   arg1 = (Dali::Toolkit::TableView *)jarg1;
78952   arg2 = (unsigned int)jarg2;
78953   {
78954     try {
78955       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78956     } catch (std::out_of_range& e) {
78957       {
78958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78959       };
78960     } catch (std::exception& e) {
78961       {
78962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78963       };
78964     } catch (Dali::DaliException e) {
78965       {
78966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78967       };
78968     } catch (...) {
78969       {
78970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78971       };
78972     }
78973   }
78974
78975   jresult = result;
78976   return jresult;
78977 }
78978
78979
78980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78981   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78982   unsigned int arg2 ;
78983   float arg3 ;
78984
78985   arg1 = (Dali::Toolkit::TableView *)jarg1;
78986   arg2 = (unsigned int)jarg2;
78987   arg3 = (float)jarg3;
78988   {
78989     try {
78990       (arg1)->SetRelativeWidth(arg2,arg3);
78991     } catch (std::out_of_range& e) {
78992       {
78993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78994       };
78995     } catch (std::exception& e) {
78996       {
78997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78998       };
78999     } catch (Dali::DaliException e) {
79000       {
79001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79002       };
79003     } catch (...) {
79004       {
79005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79006       };
79007     }
79008   }
79009
79010 }
79011
79012
79013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
79014   float jresult ;
79015   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79016   unsigned int arg2 ;
79017   float result;
79018
79019   arg1 = (Dali::Toolkit::TableView *)jarg1;
79020   arg2 = (unsigned int)jarg2;
79021   {
79022     try {
79023       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
79024     } catch (std::out_of_range& e) {
79025       {
79026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79027       };
79028     } catch (std::exception& e) {
79029       {
79030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79031       };
79032     } catch (Dali::DaliException e) {
79033       {
79034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79035       };
79036     } catch (...) {
79037       {
79038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79039       };
79040     }
79041   }
79042
79043   jresult = result;
79044   return jresult;
79045 }
79046
79047
79048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
79049   unsigned int jresult ;
79050   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79051   unsigned int result;
79052
79053   arg1 = (Dali::Toolkit::TableView *)jarg1;
79054   {
79055     try {
79056       result = (unsigned int)(arg1)->GetRows();
79057     } catch (std::out_of_range& e) {
79058       {
79059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79060       };
79061     } catch (std::exception& e) {
79062       {
79063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79064       };
79065     } catch (Dali::DaliException e) {
79066       {
79067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79068       };
79069     } catch (...) {
79070       {
79071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79072       };
79073     }
79074   }
79075
79076   jresult = result;
79077   return jresult;
79078 }
79079
79080
79081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
79082   unsigned int jresult ;
79083   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79084   unsigned int result;
79085
79086   arg1 = (Dali::Toolkit::TableView *)jarg1;
79087   {
79088     try {
79089       result = (unsigned int)(arg1)->GetColumns();
79090     } catch (std::out_of_range& e) {
79091       {
79092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79093       };
79094     } catch (std::exception& e) {
79095       {
79096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79097       };
79098     } catch (Dali::DaliException e) {
79099       {
79100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79101       };
79102     } catch (...) {
79103       {
79104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79105       };
79106     }
79107   }
79108
79109   jresult = result;
79110   return jresult;
79111 }
79112
79113
79114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
79115   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79116   Dali::Toolkit::TableView::CellPosition arg2 ;
79117   Dali::HorizontalAlignment::Type arg3 ;
79118   Dali::VerticalAlignment::Type arg4 ;
79119   Dali::Toolkit::TableView::CellPosition *argp2 ;
79120
79121   arg1 = (Dali::Toolkit::TableView *)jarg1;
79122   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
79123   if (!argp2) {
79124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
79125     return ;
79126   }
79127   arg2 = *argp2;
79128   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
79129   arg4 = (Dali::VerticalAlignment::Type)jarg4;
79130   {
79131     try {
79132       (arg1)->SetCellAlignment(arg2,arg3,arg4);
79133     } catch (std::out_of_range& e) {
79134       {
79135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79136       };
79137     } catch (std::exception& e) {
79138       {
79139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79140       };
79141     } catch (Dali::DaliException e) {
79142       {
79143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79144       };
79145     } catch (...) {
79146       {
79147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79148       };
79149     }
79150   }
79151
79152 }
79153
79154
79155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
79156   unsigned int jresult ;
79157   unsigned int result;
79158
79159   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
79160   jresult = result;
79161   return jresult;
79162 }
79163
79164
79165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
79166   int jresult ;
79167   int result;
79168
79169   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
79170   jresult = (int)result;
79171   return jresult;
79172 }
79173
79174
79175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
79176   int jresult ;
79177   int result;
79178
79179   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
79180   jresult = (int)result;
79181   return jresult;
79182 }
79183
79184
79185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
79186   int jresult ;
79187   int result;
79188
79189   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
79190   jresult = (int)result;
79191   return jresult;
79192 }
79193
79194
79195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
79196   int jresult ;
79197   int result;
79198
79199   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
79200   jresult = (int)result;
79201   return jresult;
79202 }
79203
79204
79205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
79206   int jresult ;
79207   int result;
79208
79209   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
79210   jresult = (int)result;
79211   return jresult;
79212 }
79213
79214
79215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
79216   int jresult ;
79217   int result;
79218
79219   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
79220   jresult = (int)result;
79221   return jresult;
79222 }
79223
79224
79225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79226   int jresult ;
79227   int result;
79228
79229   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79230   jresult = (int)result;
79231   return jresult;
79232 }
79233
79234
79235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79236   int jresult ;
79237   int result;
79238
79239   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79240   jresult = (int)result;
79241   return jresult;
79242 }
79243
79244
79245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
79246   int jresult ;
79247   int result;
79248
79249   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79250   jresult = (int)result;
79251   return jresult;
79252 }
79253
79254
79255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
79256   int jresult ;
79257   int result;
79258
79259   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79260   jresult = (int)result;
79261   return jresult;
79262 }
79263
79264
79265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79266   int jresult ;
79267   int result;
79268
79269   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79270   jresult = (int)result;
79271   return jresult;
79272 }
79273
79274
79275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79276   int jresult ;
79277   int result;
79278
79279   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79280   jresult = (int)result;
79281   return jresult;
79282 }
79283
79284
79285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79286   int jresult ;
79287   int result;
79288
79289   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79290   jresult = (int)result;
79291   return jresult;
79292 }
79293
79294
79295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79296   int jresult ;
79297   int result;
79298
79299   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79300   jresult = (int)result;
79301   return jresult;
79302 }
79303
79304
79305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
79306   int jresult ;
79307   int result;
79308
79309   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79310   jresult = (int)result;
79311   return jresult;
79312 }
79313
79314
79315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
79316   int jresult ;
79317   int result;
79318
79319   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79320   jresult = (int)result;
79321   return jresult;
79322 }
79323
79324
79325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
79326   int jresult ;
79327   int result;
79328
79329   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79330   jresult = (int)result;
79331   return jresult;
79332 }
79333
79334
79335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
79336   int jresult ;
79337   int result;
79338
79339   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79340   jresult = (int)result;
79341   return jresult;
79342 }
79343
79344
79345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
79346   int jresult ;
79347   int result;
79348
79349   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79350   jresult = (int)result;
79351   return jresult;
79352 }
79353
79354
79355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
79356   void * jresult ;
79357   Dali::Toolkit::TextLabel::Property *result = 0 ;
79358
79359   {
79360     try {
79361       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79362     } catch (std::out_of_range& e) {
79363       {
79364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79365       };
79366     } catch (std::exception& e) {
79367       {
79368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79369       };
79370     } catch (Dali::DaliException e) {
79371       {
79372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79373       };
79374     } catch (...) {
79375       {
79376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79377       };
79378     }
79379   }
79380
79381   jresult = (void *)result;
79382   return jresult;
79383 }
79384
79385
79386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
79387   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79388
79389   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79390   {
79391     try {
79392       delete arg1;
79393     } catch (std::out_of_range& e) {
79394       {
79395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79396       };
79397     } catch (std::exception& e) {
79398       {
79399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79400       };
79401     } catch (Dali::DaliException e) {
79402       {
79403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79404       };
79405     } catch (...) {
79406       {
79407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79408       };
79409     }
79410   }
79411
79412 }
79413
79414
79415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
79416   void * jresult ;
79417   Dali::Toolkit::TextLabel result;
79418
79419   {
79420     try {
79421       result = Dali::Toolkit::TextLabel::New();
79422     } catch (std::out_of_range& e) {
79423       {
79424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79425       };
79426     } catch (std::exception& e) {
79427       {
79428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79429       };
79430     } catch (Dali::DaliException e) {
79431       {
79432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79433       };
79434     } catch (...) {
79435       {
79436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79437       };
79438     }
79439   }
79440
79441   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79442   return jresult;
79443 }
79444
79445
79446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79447   void * jresult ;
79448   std::string *arg1 = 0 ;
79449   Dali::Toolkit::TextLabel result;
79450
79451   if (!jarg1) {
79452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79453     return 0;
79454   }
79455   std::string arg1_str(jarg1);
79456   arg1 = &arg1_str;
79457   {
79458     try {
79459       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79460     } catch (std::out_of_range& e) {
79461       {
79462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79463       };
79464     } catch (std::exception& e) {
79465       {
79466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79467       };
79468     } catch (Dali::DaliException e) {
79469       {
79470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79471       };
79472     } catch (...) {
79473       {
79474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79475       };
79476     }
79477   }
79478
79479   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79480
79481   //argout typemap for const std::string&
79482
79483   return jresult;
79484 }
79485
79486
79487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79488   void * jresult ;
79489   Dali::Toolkit::TextLabel *result = 0 ;
79490
79491   {
79492     try {
79493       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79494     } catch (std::out_of_range& e) {
79495       {
79496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79497       };
79498     } catch (std::exception& e) {
79499       {
79500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79501       };
79502     } catch (Dali::DaliException e) {
79503       {
79504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79505       };
79506     } catch (...) {
79507       {
79508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79509       };
79510     }
79511   }
79512
79513   jresult = (void *)result;
79514   return jresult;
79515 }
79516
79517
79518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79519   void * jresult ;
79520   Dali::Toolkit::TextLabel *arg1 = 0 ;
79521   Dali::Toolkit::TextLabel *result = 0 ;
79522
79523   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79524   if (!arg1) {
79525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79526     return 0;
79527   }
79528   {
79529     try {
79530       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79531     } catch (std::out_of_range& e) {
79532       {
79533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79534       };
79535     } catch (std::exception& e) {
79536       {
79537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79538       };
79539     } catch (Dali::DaliException e) {
79540       {
79541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79542       };
79543     } catch (...) {
79544       {
79545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79546       };
79547     }
79548   }
79549
79550   jresult = (void *)result;
79551   return jresult;
79552 }
79553
79554
79555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79556   void * jresult ;
79557   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79558   Dali::Toolkit::TextLabel *arg2 = 0 ;
79559   Dali::Toolkit::TextLabel *result = 0 ;
79560
79561   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79562   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79563   if (!arg2) {
79564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79565     return 0;
79566   }
79567   {
79568     try {
79569       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79570     } catch (std::out_of_range& e) {
79571       {
79572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79573       };
79574     } catch (std::exception& e) {
79575       {
79576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79577       };
79578     } catch (Dali::DaliException e) {
79579       {
79580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79581       };
79582     } catch (...) {
79583       {
79584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79585       };
79586     }
79587   }
79588
79589   jresult = (void *)result;
79590   return jresult;
79591 }
79592
79593
79594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79595   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79596
79597   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79598   {
79599     try {
79600       delete arg1;
79601     } catch (std::out_of_range& e) {
79602       {
79603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79604       };
79605     } catch (std::exception& e) {
79606       {
79607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79608       };
79609     } catch (Dali::DaliException e) {
79610       {
79611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79612       };
79613     } catch (...) {
79614       {
79615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79616       };
79617     }
79618   }
79619
79620 }
79621
79622
79623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79624   void * jresult ;
79625   Dali::BaseHandle arg1 ;
79626   Dali::BaseHandle *argp1 ;
79627   Dali::Toolkit::TextLabel result;
79628
79629   argp1 = (Dali::BaseHandle *)jarg1;
79630   if (!argp1) {
79631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79632     return 0;
79633   }
79634   arg1 = *argp1;
79635   {
79636     try {
79637       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79638     } catch (std::out_of_range& e) {
79639       {
79640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79641       };
79642     } catch (std::exception& e) {
79643       {
79644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79645       };
79646     } catch (Dali::DaliException e) {
79647       {
79648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79649       };
79650     } catch (...) {
79651       {
79652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79653       };
79654     }
79655   }
79656
79657   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79658   return jresult;
79659 }
79660
79661
79662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79663   void * jresult ;
79664   Dali::Toolkit::AccessibilityManager *result = 0 ;
79665
79666   {
79667     try {
79668       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79669     } catch (std::out_of_range& e) {
79670       {
79671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79672       };
79673     } catch (std::exception& e) {
79674       {
79675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79676       };
79677     } catch (Dali::DaliException e) {
79678       {
79679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79680       };
79681     } catch (...) {
79682       {
79683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79684       };
79685     }
79686   }
79687
79688   jresult = (void *)result;
79689   return jresult;
79690 }
79691
79692
79693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79694   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79695
79696   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79697   {
79698     try {
79699       delete arg1;
79700     } catch (std::out_of_range& e) {
79701       {
79702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79703       };
79704     } catch (std::exception& e) {
79705       {
79706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79707       };
79708     } catch (Dali::DaliException e) {
79709       {
79710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79711       };
79712     } catch (...) {
79713       {
79714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79715       };
79716     }
79717   }
79718
79719 }
79720
79721
79722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79723   void * jresult ;
79724   Dali::Toolkit::AccessibilityManager result;
79725
79726   {
79727     try {
79728       result = Dali::Toolkit::AccessibilityManager::Get();
79729     } catch (std::out_of_range& e) {
79730       {
79731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79732       };
79733     } catch (std::exception& e) {
79734       {
79735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79736       };
79737     } catch (Dali::DaliException e) {
79738       {
79739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79740       };
79741     } catch (...) {
79742       {
79743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79744       };
79745     }
79746   }
79747
79748   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79749   return jresult;
79750 }
79751
79752
79753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79754   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79755   Dali::Actor arg2 ;
79756   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79757   std::string *arg4 = 0 ;
79758   Dali::Actor *argp2 ;
79759
79760   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79761   argp2 = (Dali::Actor *)jarg2;
79762   if (!argp2) {
79763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79764     return ;
79765   }
79766   arg2 = *argp2;
79767   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79768   if (!jarg4) {
79769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79770     return ;
79771   }
79772   std::string arg4_str(jarg4);
79773   arg4 = &arg4_str;
79774   {
79775     try {
79776       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79777     } catch (std::out_of_range& e) {
79778       {
79779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79780       };
79781     } catch (std::exception& e) {
79782       {
79783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79784       };
79785     } catch (Dali::DaliException e) {
79786       {
79787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79788       };
79789     } catch (...) {
79790       {
79791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79792       };
79793     }
79794   }
79795
79796
79797   //argout typemap for const std::string&
79798
79799 }
79800
79801
79802 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79803   char * jresult ;
79804   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79805   Dali::Actor arg2 ;
79806   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79807   Dali::Actor *argp2 ;
79808   std::string result;
79809
79810   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79811   argp2 = (Dali::Actor *)jarg2;
79812   if (!argp2) {
79813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79814     return 0;
79815   }
79816   arg2 = *argp2;
79817   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79818   {
79819     try {
79820       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79821     } catch (std::out_of_range& e) {
79822       {
79823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79824       };
79825     } catch (std::exception& e) {
79826       {
79827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79828       };
79829     } catch (Dali::DaliException e) {
79830       {
79831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79832       };
79833     } catch (...) {
79834       {
79835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79836       };
79837     }
79838   }
79839
79840   jresult = SWIG_csharp_string_callback((&result)->c_str());
79841   return jresult;
79842 }
79843
79844
79845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79846   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79847   Dali::Actor arg2 ;
79848   unsigned int arg3 ;
79849   Dali::Actor *argp2 ;
79850
79851   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79852   argp2 = (Dali::Actor *)jarg2;
79853   if (!argp2) {
79854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79855     return ;
79856   }
79857   arg2 = *argp2;
79858   arg3 = (unsigned int)jarg3;
79859   {
79860     try {
79861       (arg1)->SetFocusOrder(arg2,arg3);
79862     } catch (std::out_of_range& e) {
79863       {
79864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79865       };
79866     } catch (std::exception& e) {
79867       {
79868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79869       };
79870     } catch (Dali::DaliException e) {
79871       {
79872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79873       };
79874     } catch (...) {
79875       {
79876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79877       };
79878     }
79879   }
79880
79881 }
79882
79883
79884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79885   unsigned int jresult ;
79886   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79887   Dali::Actor arg2 ;
79888   Dali::Actor *argp2 ;
79889   unsigned int result;
79890
79891   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79892   argp2 = (Dali::Actor *)jarg2;
79893   if (!argp2) {
79894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79895     return 0;
79896   }
79897   arg2 = *argp2;
79898   {
79899     try {
79900       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79901     } catch (std::out_of_range& e) {
79902       {
79903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79904       };
79905     } catch (std::exception& e) {
79906       {
79907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79908       };
79909     } catch (Dali::DaliException e) {
79910       {
79911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79912       };
79913     } catch (...) {
79914       {
79915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79916       };
79917     }
79918   }
79919
79920   jresult = result;
79921   return jresult;
79922 }
79923
79924
79925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79926   unsigned int jresult ;
79927   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79928   unsigned int result;
79929
79930   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79931   {
79932     try {
79933       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79934     } catch (std::out_of_range& e) {
79935       {
79936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79937       };
79938     } catch (std::exception& e) {
79939       {
79940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79941       };
79942     } catch (Dali::DaliException e) {
79943       {
79944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79945       };
79946     } catch (...) {
79947       {
79948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79949       };
79950     }
79951   }
79952
79953   jresult = result;
79954   return jresult;
79955 }
79956
79957
79958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79959   void * jresult ;
79960   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79961   unsigned int arg2 ;
79962   Dali::Actor result;
79963
79964   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79965   arg2 = (unsigned int)jarg2;
79966   {
79967     try {
79968       result = (arg1)->GetActorByFocusOrder(arg2);
79969     } catch (std::out_of_range& e) {
79970       {
79971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79972       };
79973     } catch (std::exception& e) {
79974       {
79975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79976       };
79977     } catch (Dali::DaliException e) {
79978       {
79979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79980       };
79981     } catch (...) {
79982       {
79983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79984       };
79985     }
79986   }
79987
79988   jresult = new Dali::Actor((const Dali::Actor &)result);
79989   return jresult;
79990 }
79991
79992
79993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79994   unsigned int jresult ;
79995   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79996   Dali::Actor arg2 ;
79997   Dali::Actor *argp2 ;
79998   bool result;
79999
80000   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80001   argp2 = (Dali::Actor *)jarg2;
80002   if (!argp2) {
80003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80004     return 0;
80005   }
80006   arg2 = *argp2;
80007   {
80008     try {
80009       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
80010     } catch (std::out_of_range& e) {
80011       {
80012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80013       };
80014     } catch (std::exception& e) {
80015       {
80016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80017       };
80018     } catch (Dali::DaliException e) {
80019       {
80020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80021       };
80022     } catch (...) {
80023       {
80024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80025       };
80026     }
80027   }
80028
80029   jresult = result;
80030   return jresult;
80031 }
80032
80033
80034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
80035   void * jresult ;
80036   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80037   Dali::Actor result;
80038
80039   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80040   {
80041     try {
80042       result = (arg1)->GetCurrentFocusActor();
80043     } catch (std::out_of_range& e) {
80044       {
80045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80046       };
80047     } catch (std::exception& e) {
80048       {
80049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80050       };
80051     } catch (Dali::DaliException e) {
80052       {
80053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80054       };
80055     } catch (...) {
80056       {
80057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80058       };
80059     }
80060   }
80061
80062   jresult = new Dali::Actor((const Dali::Actor &)result);
80063   return jresult;
80064 }
80065
80066
80067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
80068   void * jresult ;
80069   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80070   Dali::Actor result;
80071
80072   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80073   {
80074     try {
80075       result = (arg1)->GetCurrentFocusGroup();
80076     } catch (std::out_of_range& e) {
80077       {
80078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80079       };
80080     } catch (std::exception& e) {
80081       {
80082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80083       };
80084     } catch (Dali::DaliException e) {
80085       {
80086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80087       };
80088     } catch (...) {
80089       {
80090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80091       };
80092     }
80093   }
80094
80095   jresult = new Dali::Actor((const Dali::Actor &)result);
80096   return jresult;
80097 }
80098
80099
80100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
80101   unsigned int jresult ;
80102   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80103   unsigned int result;
80104
80105   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80106   {
80107     try {
80108       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
80109     } catch (std::out_of_range& e) {
80110       {
80111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80112       };
80113     } catch (std::exception& e) {
80114       {
80115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80116       };
80117     } catch (Dali::DaliException e) {
80118       {
80119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80120       };
80121     } catch (...) {
80122       {
80123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80124       };
80125     }
80126   }
80127
80128   jresult = result;
80129   return jresult;
80130 }
80131
80132
80133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
80134   unsigned int jresult ;
80135   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80136   bool result;
80137
80138   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80139   {
80140     try {
80141       result = (bool)(arg1)->MoveFocusForward();
80142     } catch (std::out_of_range& e) {
80143       {
80144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80145       };
80146     } catch (std::exception& e) {
80147       {
80148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80149       };
80150     } catch (Dali::DaliException e) {
80151       {
80152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80153       };
80154     } catch (...) {
80155       {
80156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80157       };
80158     }
80159   }
80160
80161   jresult = result;
80162   return jresult;
80163 }
80164
80165
80166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
80167   unsigned int jresult ;
80168   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80169   bool result;
80170
80171   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80172   {
80173     try {
80174       result = (bool)(arg1)->MoveFocusBackward();
80175     } catch (std::out_of_range& e) {
80176       {
80177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80178       };
80179     } catch (std::exception& e) {
80180       {
80181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80182       };
80183     } catch (Dali::DaliException e) {
80184       {
80185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80186       };
80187     } catch (...) {
80188       {
80189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80190       };
80191     }
80192   }
80193
80194   jresult = result;
80195   return jresult;
80196 }
80197
80198
80199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
80200   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80201
80202   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80203   {
80204     try {
80205       (arg1)->ClearFocus();
80206     } catch (std::out_of_range& e) {
80207       {
80208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80209       };
80210     } catch (std::exception& e) {
80211       {
80212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80213       };
80214     } catch (Dali::DaliException e) {
80215       {
80216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80217       };
80218     } catch (...) {
80219       {
80220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80221       };
80222     }
80223   }
80224
80225 }
80226
80227
80228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
80229   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80230
80231   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80232   {
80233     try {
80234       (arg1)->Reset();
80235     } catch (std::out_of_range& e) {
80236       {
80237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80238       };
80239     } catch (std::exception& e) {
80240       {
80241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80242       };
80243     } catch (Dali::DaliException e) {
80244       {
80245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80246       };
80247     } catch (...) {
80248       {
80249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80250       };
80251     }
80252   }
80253
80254 }
80255
80256
80257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
80258   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80259   Dali::Actor arg2 ;
80260   bool arg3 ;
80261   Dali::Actor *argp2 ;
80262
80263   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80264   argp2 = (Dali::Actor *)jarg2;
80265   if (!argp2) {
80266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80267     return ;
80268   }
80269   arg2 = *argp2;
80270   arg3 = jarg3 ? true : false;
80271   {
80272     try {
80273       (arg1)->SetFocusGroup(arg2,arg3);
80274     } catch (std::out_of_range& e) {
80275       {
80276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80277       };
80278     } catch (std::exception& e) {
80279       {
80280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80281       };
80282     } catch (Dali::DaliException e) {
80283       {
80284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80285       };
80286     } catch (...) {
80287       {
80288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80289       };
80290     }
80291   }
80292
80293 }
80294
80295
80296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
80297   unsigned int jresult ;
80298   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80299   Dali::Actor arg2 ;
80300   Dali::Actor *argp2 ;
80301   bool result;
80302
80303   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80304   argp2 = (Dali::Actor *)jarg2;
80305   if (!argp2) {
80306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80307     return 0;
80308   }
80309   arg2 = *argp2;
80310   {
80311     try {
80312       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80313     } catch (std::out_of_range& e) {
80314       {
80315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80316       };
80317     } catch (std::exception& e) {
80318       {
80319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80320       };
80321     } catch (Dali::DaliException e) {
80322       {
80323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80324       };
80325     } catch (...) {
80326       {
80327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80328       };
80329     }
80330   }
80331
80332   jresult = result;
80333   return jresult;
80334 }
80335
80336
80337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80338   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80339   bool arg2 ;
80340
80341   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80342   arg2 = jarg2 ? true : false;
80343   {
80344     try {
80345       (arg1)->SetGroupMode(arg2);
80346     } catch (std::out_of_range& e) {
80347       {
80348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80349       };
80350     } catch (std::exception& e) {
80351       {
80352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80353       };
80354     } catch (Dali::DaliException e) {
80355       {
80356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80357       };
80358     } catch (...) {
80359       {
80360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80361       };
80362     }
80363   }
80364
80365 }
80366
80367
80368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
80369   unsigned int jresult ;
80370   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80371   bool result;
80372
80373   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80374   {
80375     try {
80376       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80377     } catch (std::out_of_range& e) {
80378       {
80379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80380       };
80381     } catch (std::exception& e) {
80382       {
80383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80384       };
80385     } catch (Dali::DaliException e) {
80386       {
80387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80388       };
80389     } catch (...) {
80390       {
80391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80392       };
80393     }
80394   }
80395
80396   jresult = result;
80397   return jresult;
80398 }
80399
80400
80401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80402   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80403   bool arg2 ;
80404
80405   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80406   arg2 = jarg2 ? true : false;
80407   {
80408     try {
80409       (arg1)->SetWrapMode(arg2);
80410     } catch (std::out_of_range& e) {
80411       {
80412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80413       };
80414     } catch (std::exception& e) {
80415       {
80416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80417       };
80418     } catch (Dali::DaliException e) {
80419       {
80420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80421       };
80422     } catch (...) {
80423       {
80424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80425       };
80426     }
80427   }
80428
80429 }
80430
80431
80432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80433   unsigned int jresult ;
80434   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80435   bool result;
80436
80437   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80438   {
80439     try {
80440       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80441     } catch (std::out_of_range& e) {
80442       {
80443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80444       };
80445     } catch (std::exception& e) {
80446       {
80447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80448       };
80449     } catch (Dali::DaliException e) {
80450       {
80451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80452       };
80453     } catch (...) {
80454       {
80455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80456       };
80457     }
80458   }
80459
80460   jresult = result;
80461   return jresult;
80462 }
80463
80464
80465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80466   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80467   Dali::Actor arg2 ;
80468   Dali::Actor *argp2 ;
80469
80470   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80471   argp2 = (Dali::Actor *)jarg2;
80472   if (!argp2) {
80473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80474     return ;
80475   }
80476   arg2 = *argp2;
80477   {
80478     try {
80479       (arg1)->SetFocusIndicatorActor(arg2);
80480     } catch (std::out_of_range& e) {
80481       {
80482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80483       };
80484     } catch (std::exception& e) {
80485       {
80486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80487       };
80488     } catch (Dali::DaliException e) {
80489       {
80490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80491       };
80492     } catch (...) {
80493       {
80494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80495       };
80496     }
80497   }
80498
80499 }
80500
80501
80502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80503   void * jresult ;
80504   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80505   Dali::Actor result;
80506
80507   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80508   {
80509     try {
80510       result = (arg1)->GetFocusIndicatorActor();
80511     } catch (std::out_of_range& e) {
80512       {
80513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80514       };
80515     } catch (std::exception& e) {
80516       {
80517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80518       };
80519     } catch (Dali::DaliException e) {
80520       {
80521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80522       };
80523     } catch (...) {
80524       {
80525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80526       };
80527     }
80528   }
80529
80530   jresult = new Dali::Actor((const Dali::Actor &)result);
80531   return jresult;
80532 }
80533
80534
80535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80536   void * jresult ;
80537   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80538   Dali::Actor arg2 ;
80539   Dali::Actor *argp2 ;
80540   Dali::Actor result;
80541
80542   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80543   argp2 = (Dali::Actor *)jarg2;
80544   if (!argp2) {
80545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80546     return 0;
80547   }
80548   arg2 = *argp2;
80549   {
80550     try {
80551       result = (arg1)->GetFocusGroup(arg2);
80552     } catch (std::out_of_range& e) {
80553       {
80554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80555       };
80556     } catch (std::exception& e) {
80557       {
80558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80559       };
80560     } catch (Dali::DaliException e) {
80561       {
80562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80563       };
80564     } catch (...) {
80565       {
80566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80567       };
80568     }
80569   }
80570
80571   jresult = new Dali::Actor((const Dali::Actor &)result);
80572   return jresult;
80573 }
80574
80575
80576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80577   void * jresult ;
80578   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80579   Dali::Vector2 result;
80580
80581   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80582   {
80583     try {
80584       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80585     } catch (std::out_of_range& e) {
80586       {
80587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80588       };
80589     } catch (std::exception& e) {
80590       {
80591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80592       };
80593     } catch (Dali::DaliException e) {
80594       {
80595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80596       };
80597     } catch (...) {
80598       {
80599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80600       };
80601     }
80602   }
80603
80604   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80605   return jresult;
80606 }
80607
80608
80609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80610   void * jresult ;
80611   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80612   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80613
80614   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80615   {
80616     try {
80617       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80618     } catch (std::out_of_range& e) {
80619       {
80620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80621       };
80622     } catch (std::exception& e) {
80623       {
80624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80625       };
80626     } catch (Dali::DaliException e) {
80627       {
80628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80629       };
80630     } catch (...) {
80631       {
80632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80633       };
80634     }
80635   }
80636
80637   jresult = (void *)result;
80638   return jresult;
80639 }
80640
80641
80642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80643   void * jresult ;
80644   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80645   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80646
80647   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80648   {
80649     try {
80650       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80651     } catch (std::out_of_range& e) {
80652       {
80653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80654       };
80655     } catch (std::exception& e) {
80656       {
80657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80658       };
80659     } catch (Dali::DaliException e) {
80660       {
80661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80662       };
80663     } catch (...) {
80664       {
80665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80666       };
80667     }
80668   }
80669
80670   jresult = (void *)result;
80671   return jresult;
80672 }
80673
80674
80675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80676   void * jresult ;
80677   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80678   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80679
80680   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80681   {
80682     try {
80683       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80684     } catch (std::out_of_range& e) {
80685       {
80686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80687       };
80688     } catch (std::exception& e) {
80689       {
80690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80691       };
80692     } catch (Dali::DaliException e) {
80693       {
80694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80695       };
80696     } catch (...) {
80697       {
80698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80699       };
80700     }
80701   }
80702
80703   jresult = (void *)result;
80704   return jresult;
80705 }
80706
80707
80708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80709   void * jresult ;
80710   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80711   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80712
80713   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80714   {
80715     try {
80716       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80717     } catch (std::out_of_range& e) {
80718       {
80719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80720       };
80721     } catch (std::exception& e) {
80722       {
80723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80724       };
80725     } catch (Dali::DaliException e) {
80726       {
80727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80728       };
80729     } catch (...) {
80730       {
80731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80732       };
80733     }
80734   }
80735
80736   jresult = (void *)result;
80737   return jresult;
80738 }
80739
80740
80741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80742   void * jresult ;
80743   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80744   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80745
80746   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80747   {
80748     try {
80749       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80750     } catch (std::out_of_range& e) {
80751       {
80752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80753       };
80754     } catch (std::exception& e) {
80755       {
80756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80757       };
80758     } catch (Dali::DaliException e) {
80759       {
80760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80761       };
80762     } catch (...) {
80763       {
80764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80765       };
80766     }
80767   }
80768
80769   jresult = (void *)result;
80770   return jresult;
80771 }
80772
80773
80774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80775   void * jresult ;
80776   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80777   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80778
80779   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80780   {
80781     try {
80782       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80783     } catch (std::out_of_range& e) {
80784       {
80785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80786       };
80787     } catch (std::exception& e) {
80788       {
80789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80790       };
80791     } catch (Dali::DaliException e) {
80792       {
80793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80794       };
80795     } catch (...) {
80796       {
80797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80798       };
80799     }
80800   }
80801
80802   jresult = (void *)result;
80803   return jresult;
80804 }
80805
80806
80807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80808   void * jresult ;
80809   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80810   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80811
80812   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80813   {
80814     try {
80815       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80816     } catch (std::out_of_range& e) {
80817       {
80818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80819       };
80820     } catch (std::exception& e) {
80821       {
80822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80823       };
80824     } catch (Dali::DaliException e) {
80825       {
80826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80827       };
80828     } catch (...) {
80829       {
80830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80831       };
80832     }
80833   }
80834
80835   jresult = (void *)result;
80836   return jresult;
80837 }
80838
80839
80840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80841   void * jresult ;
80842   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80843   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80844
80845   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80846   {
80847     try {
80848       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80849     } catch (std::out_of_range& e) {
80850       {
80851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80852       };
80853     } catch (std::exception& e) {
80854       {
80855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80856       };
80857     } catch (Dali::DaliException e) {
80858       {
80859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80860       };
80861     } catch (...) {
80862       {
80863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80864       };
80865     }
80866   }
80867
80868   jresult = (void *)result;
80869   return jresult;
80870 }
80871
80872
80873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80874   void * jresult ;
80875   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80876   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80877
80878   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80879   {
80880     try {
80881       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80882     } catch (std::out_of_range& e) {
80883       {
80884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80885       };
80886     } catch (std::exception& e) {
80887       {
80888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80889       };
80890     } catch (Dali::DaliException e) {
80891       {
80892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80893       };
80894     } catch (...) {
80895       {
80896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80897       };
80898     }
80899   }
80900
80901   jresult = (void *)result;
80902   return jresult;
80903 }
80904
80905
80906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80907   void * jresult ;
80908   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80909   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80910
80911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80912   {
80913     try {
80914       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80915     } catch (std::out_of_range& e) {
80916       {
80917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80918       };
80919     } catch (std::exception& e) {
80920       {
80921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80922       };
80923     } catch (Dali::DaliException e) {
80924       {
80925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80926       };
80927     } catch (...) {
80928       {
80929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80930       };
80931     }
80932   }
80933
80934   jresult = (void *)result;
80935   return jresult;
80936 }
80937
80938
80939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80940   void * jresult ;
80941   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80942   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80943
80944   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80945   {
80946     try {
80947       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80948     } catch (std::out_of_range& e) {
80949       {
80950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80951       };
80952     } catch (std::exception& e) {
80953       {
80954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80955       };
80956     } catch (Dali::DaliException e) {
80957       {
80958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80959       };
80960     } catch (...) {
80961       {
80962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80963       };
80964     }
80965   }
80966
80967   jresult = (void *)result;
80968   return jresult;
80969 }
80970
80971
80972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80973   void * jresult ;
80974   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80975   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80976
80977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80978   {
80979     try {
80980       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80981     } catch (std::out_of_range& e) {
80982       {
80983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80984       };
80985     } catch (std::exception& e) {
80986       {
80987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80988       };
80989     } catch (Dali::DaliException e) {
80990       {
80991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80992       };
80993     } catch (...) {
80994       {
80995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80996       };
80997     }
80998   }
80999
81000   jresult = (void *)result;
81001   return jresult;
81002 }
81003
81004
81005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
81006   void * jresult ;
81007   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81008   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81009
81010   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81011   {
81012     try {
81013       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
81014     } catch (std::out_of_range& e) {
81015       {
81016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81017       };
81018     } catch (std::exception& e) {
81019       {
81020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81021       };
81022     } catch (Dali::DaliException e) {
81023       {
81024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81025       };
81026     } catch (...) {
81027       {
81028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81029       };
81030     }
81031   }
81032
81033   jresult = (void *)result;
81034   return jresult;
81035 }
81036
81037
81038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
81039   void * jresult ;
81040   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81041   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81042
81043   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81044   {
81045     try {
81046       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
81047     } catch (std::out_of_range& e) {
81048       {
81049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81050       };
81051     } catch (std::exception& e) {
81052       {
81053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81054       };
81055     } catch (Dali::DaliException e) {
81056       {
81057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81058       };
81059     } catch (...) {
81060       {
81061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81062       };
81063     }
81064   }
81065
81066   jresult = (void *)result;
81067   return jresult;
81068 }
81069
81070
81071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
81072   void * jresult ;
81073   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81074   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81075
81076   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81077   {
81078     try {
81079       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
81080     } catch (std::out_of_range& e) {
81081       {
81082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81083       };
81084     } catch (std::exception& e) {
81085       {
81086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81087       };
81088     } catch (Dali::DaliException e) {
81089       {
81090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81091       };
81092     } catch (...) {
81093       {
81094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81095       };
81096     }
81097   }
81098
81099   jresult = (void *)result;
81100   return jresult;
81101 }
81102
81103
81104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
81105   void * jresult ;
81106   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81107   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81108
81109   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81110   {
81111     try {
81112       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
81113     } catch (std::out_of_range& e) {
81114       {
81115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81116       };
81117     } catch (std::exception& e) {
81118       {
81119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81120       };
81121     } catch (Dali::DaliException e) {
81122       {
81123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81124       };
81125     } catch (...) {
81126       {
81127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81128       };
81129     }
81130   }
81131
81132   jresult = (void *)result;
81133   return jresult;
81134 }
81135
81136
81137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
81138   void * jresult ;
81139   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81140   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81141
81142   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81143   {
81144     try {
81145       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
81146     } catch (std::out_of_range& e) {
81147       {
81148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81149       };
81150     } catch (std::exception& e) {
81151       {
81152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81153       };
81154     } catch (Dali::DaliException e) {
81155       {
81156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81157       };
81158     } catch (...) {
81159       {
81160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81161       };
81162     }
81163   }
81164
81165   jresult = (void *)result;
81166   return jresult;
81167 }
81168
81169
81170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
81171   void * jresult ;
81172   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81173   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81174
81175   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81176   {
81177     try {
81178       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
81179     } catch (std::out_of_range& e) {
81180       {
81181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81182       };
81183     } catch (std::exception& e) {
81184       {
81185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81186       };
81187     } catch (Dali::DaliException e) {
81188       {
81189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81190       };
81191     } catch (...) {
81192       {
81193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81194       };
81195     }
81196   }
81197
81198   jresult = (void *)result;
81199   return jresult;
81200 }
81201
81202
81203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
81204   void * jresult ;
81205   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81206   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81207
81208   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81209   {
81210     try {
81211       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
81212     } catch (std::out_of_range& e) {
81213       {
81214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81215       };
81216     } catch (std::exception& e) {
81217       {
81218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81219       };
81220     } catch (Dali::DaliException e) {
81221       {
81222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81223       };
81224     } catch (...) {
81225       {
81226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81227       };
81228     }
81229   }
81230
81231   jresult = (void *)result;
81232   return jresult;
81233 }
81234
81235
81236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
81237   void * jresult ;
81238   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81239   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81240
81241   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81242   {
81243     try {
81244       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
81245     } catch (std::out_of_range& e) {
81246       {
81247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81248       };
81249     } catch (std::exception& e) {
81250       {
81251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81252       };
81253     } catch (Dali::DaliException e) {
81254       {
81255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81256       };
81257     } catch (...) {
81258       {
81259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81260       };
81261     }
81262   }
81263
81264   jresult = (void *)result;
81265   return jresult;
81266 }
81267
81268
81269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
81270   void * jresult ;
81271   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81272   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81273
81274   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81275   {
81276     try {
81277       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
81278     } catch (std::out_of_range& e) {
81279       {
81280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81281       };
81282     } catch (std::exception& e) {
81283       {
81284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81285       };
81286     } catch (Dali::DaliException e) {
81287       {
81288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81289       };
81290     } catch (...) {
81291       {
81292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81293       };
81294     }
81295   }
81296
81297   jresult = (void *)result;
81298   return jresult;
81299 }
81300
81301
81302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
81303   void * jresult ;
81304   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81305   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81306
81307   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81308   {
81309     try {
81310       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
81311     } catch (std::out_of_range& e) {
81312       {
81313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81314       };
81315     } catch (std::exception& e) {
81316       {
81317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81318       };
81319     } catch (Dali::DaliException e) {
81320       {
81321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81322       };
81323     } catch (...) {
81324       {
81325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81326       };
81327     }
81328   }
81329
81330   jresult = (void *)result;
81331   return jresult;
81332 }
81333
81334
81335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
81336   void * jresult ;
81337   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81338   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81339
81340   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81341   {
81342     try {
81343       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
81344     } catch (std::out_of_range& e) {
81345       {
81346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81347       };
81348     } catch (std::exception& e) {
81349       {
81350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81351       };
81352     } catch (Dali::DaliException e) {
81353       {
81354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81355       };
81356     } catch (...) {
81357       {
81358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81359       };
81360     }
81361   }
81362
81363   jresult = (void *)result;
81364   return jresult;
81365 }
81366
81367
81368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
81369   void * jresult ;
81370   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81371   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81372
81373   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81374   {
81375     try {
81376       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
81377     } catch (std::out_of_range& e) {
81378       {
81379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (std::exception& e) {
81382       {
81383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81384       };
81385     } catch (Dali::DaliException e) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81388       };
81389     } catch (...) {
81390       {
81391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81392       };
81393     }
81394   }
81395
81396   jresult = (void *)result;
81397   return jresult;
81398 }
81399
81400
81401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
81402   void * jresult ;
81403   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81404   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81405
81406   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81407   {
81408     try {
81409       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
81410     } catch (std::out_of_range& e) {
81411       {
81412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81413       };
81414     } catch (std::exception& e) {
81415       {
81416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81417       };
81418     } catch (Dali::DaliException e) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81421       };
81422     } catch (...) {
81423       {
81424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81425       };
81426     }
81427   }
81428
81429   jresult = (void *)result;
81430   return jresult;
81431 }
81432
81433
81434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81435   void * jresult ;
81436   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81437   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81438
81439   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81440   {
81441     try {
81442       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81443     } catch (std::out_of_range& e) {
81444       {
81445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81446       };
81447     } catch (std::exception& e) {
81448       {
81449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81450       };
81451     } catch (Dali::DaliException e) {
81452       {
81453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81454       };
81455     } catch (...) {
81456       {
81457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81458       };
81459     }
81460   }
81461
81462   jresult = (void *)result;
81463   return jresult;
81464 }
81465
81466
81467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
81468   void * jresult ;
81469   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81470   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81471
81472   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81473   {
81474     try {
81475       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
81476     } catch (std::out_of_range& e) {
81477       {
81478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81479       };
81480     } catch (std::exception& e) {
81481       {
81482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81483       };
81484     } catch (Dali::DaliException e) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81487       };
81488     } catch (...) {
81489       {
81490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81491       };
81492     }
81493   }
81494
81495   jresult = (void *)result;
81496   return jresult;
81497 }
81498
81499
81500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81501   void * jresult ;
81502   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81503   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81504
81505   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81506   {
81507     try {
81508       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81509     } catch (std::out_of_range& e) {
81510       {
81511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81512       };
81513     } catch (std::exception& e) {
81514       {
81515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81516       };
81517     } catch (Dali::DaliException e) {
81518       {
81519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81520       };
81521     } catch (...) {
81522       {
81523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81524       };
81525     }
81526   }
81527
81528   jresult = (void *)result;
81529   return jresult;
81530 }
81531
81532
81533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81534   void * jresult ;
81535   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81536   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81537
81538   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81539   {
81540     try {
81541       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81542     } catch (std::out_of_range& e) {
81543       {
81544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81545       };
81546     } catch (std::exception& e) {
81547       {
81548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81549       };
81550     } catch (Dali::DaliException e) {
81551       {
81552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81553       };
81554     } catch (...) {
81555       {
81556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81557       };
81558     }
81559   }
81560
81561   jresult = (void *)result;
81562   return jresult;
81563 }
81564
81565
81566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81567   void * jresult ;
81568   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81569   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81570
81571   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81572   {
81573     try {
81574       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81575     } catch (std::out_of_range& e) {
81576       {
81577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81578       };
81579     } catch (std::exception& e) {
81580       {
81581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81582       };
81583     } catch (Dali::DaliException e) {
81584       {
81585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81586       };
81587     } catch (...) {
81588       {
81589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81590       };
81591     }
81592   }
81593
81594   jresult = (void *)result;
81595   return jresult;
81596 }
81597
81598
81599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81600   void * jresult ;
81601   Dali::Toolkit::StyleManager *result = 0 ;
81602
81603   {
81604     try {
81605       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81606     } catch (std::out_of_range& e) {
81607       {
81608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81609       };
81610     } catch (std::exception& e) {
81611       {
81612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81613       };
81614     } catch (Dali::DaliException e) {
81615       {
81616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81617       };
81618     } catch (...) {
81619       {
81620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81621       };
81622     }
81623   }
81624
81625   jresult = (void *)result;
81626   return jresult;
81627 }
81628
81629
81630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81631   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81632
81633   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81634   {
81635     try {
81636       delete arg1;
81637     } catch (std::out_of_range& e) {
81638       {
81639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81640       };
81641     } catch (std::exception& e) {
81642       {
81643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81644       };
81645     } catch (Dali::DaliException e) {
81646       {
81647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81648       };
81649     } catch (...) {
81650       {
81651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81652       };
81653     }
81654   }
81655
81656 }
81657
81658
81659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81660   void * jresult ;
81661   Dali::Toolkit::StyleManager result;
81662
81663   {
81664     try {
81665       result = Dali::Toolkit::StyleManager::Get();
81666     } catch (std::out_of_range& e) {
81667       {
81668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81669       };
81670     } catch (std::exception& e) {
81671       {
81672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81673       };
81674     } catch (Dali::DaliException e) {
81675       {
81676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81677       };
81678     } catch (...) {
81679       {
81680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81681       };
81682     }
81683   }
81684
81685   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81686   return jresult;
81687 }
81688
81689
81690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81691   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81692   std::string *arg2 = 0 ;
81693
81694   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81695   if (!jarg2) {
81696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81697     return ;
81698   }
81699   std::string arg2_str(jarg2);
81700   arg2 = &arg2_str;
81701   {
81702     try {
81703       (arg1)->ApplyTheme((std::string const &)*arg2);
81704     } catch (std::out_of_range& e) {
81705       {
81706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81707       };
81708     } catch (std::exception& e) {
81709       {
81710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81711       };
81712     } catch (Dali::DaliException e) {
81713       {
81714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81715       };
81716     } catch (...) {
81717       {
81718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81719       };
81720     }
81721   }
81722
81723
81724   //argout typemap for const std::string&
81725
81726 }
81727
81728
81729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81730   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81731
81732   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81733   {
81734     try {
81735       (arg1)->ApplyDefaultTheme();
81736     } catch (std::out_of_range& e) {
81737       {
81738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81739       };
81740     } catch (std::exception& e) {
81741       {
81742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81743       };
81744     } catch (Dali::DaliException e) {
81745       {
81746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81747       };
81748     } catch (...) {
81749       {
81750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81751       };
81752     }
81753   }
81754
81755 }
81756
81757
81758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81759   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81760   std::string *arg2 = 0 ;
81761   Dali::Property::Value *arg3 = 0 ;
81762
81763   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81764   if (!jarg2) {
81765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81766     return ;
81767   }
81768   std::string arg2_str(jarg2);
81769   arg2 = &arg2_str;
81770   arg3 = (Dali::Property::Value *)jarg3;
81771   if (!arg3) {
81772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81773     return ;
81774   }
81775   {
81776     try {
81777       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81778     } catch (std::out_of_range& e) {
81779       {
81780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81781       };
81782     } catch (std::exception& e) {
81783       {
81784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81785       };
81786     } catch (Dali::DaliException e) {
81787       {
81788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81789       };
81790     } catch (...) {
81791       {
81792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81793       };
81794     }
81795   }
81796
81797
81798   //argout typemap for const std::string&
81799
81800 }
81801
81802
81803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81804   unsigned int jresult ;
81805   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81806   std::string *arg2 = 0 ;
81807   Dali::Property::Value *arg3 = 0 ;
81808   bool result;
81809
81810   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81811   if (!jarg2) {
81812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81813     return 0;
81814   }
81815   std::string arg2_str(jarg2);
81816   arg2 = &arg2_str;
81817   arg3 = (Dali::Property::Value *)jarg3;
81818   if (!arg3) {
81819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81820     return 0;
81821   }
81822   {
81823     try {
81824       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81825     } catch (std::out_of_range& e) {
81826       {
81827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81828       };
81829     } catch (std::exception& e) {
81830       {
81831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81832       };
81833     } catch (Dali::DaliException e) {
81834       {
81835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81836       };
81837     } catch (...) {
81838       {
81839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81840       };
81841     }
81842   }
81843
81844   jresult = result;
81845
81846   //argout typemap for const std::string&
81847
81848   return jresult;
81849 }
81850
81851
81852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81853   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81854   Dali::Toolkit::Control arg2 ;
81855   std::string *arg3 = 0 ;
81856   std::string *arg4 = 0 ;
81857   Dali::Toolkit::Control *argp2 ;
81858
81859   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81860   argp2 = (Dali::Toolkit::Control *)jarg2;
81861   if (!argp2) {
81862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81863     return ;
81864   }
81865   arg2 = *argp2;
81866   if (!jarg3) {
81867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81868     return ;
81869   }
81870   std::string arg3_str(jarg3);
81871   arg3 = &arg3_str;
81872   if (!jarg4) {
81873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81874     return ;
81875   }
81876   std::string arg4_str(jarg4);
81877   arg4 = &arg4_str;
81878   {
81879     try {
81880       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81881     } catch (std::out_of_range& e) {
81882       {
81883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81884       };
81885     } catch (std::exception& e) {
81886       {
81887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81888       };
81889     } catch (Dali::DaliException e) {
81890       {
81891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81892       };
81893     } catch (...) {
81894       {
81895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81896       };
81897     }
81898   }
81899
81900
81901   //argout typemap for const std::string&
81902
81903
81904   //argout typemap for const std::string&
81905
81906 }
81907
81908
81909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81910   void * jresult ;
81911   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81912   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81913
81914   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81915   {
81916     try {
81917       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81918     } catch (std::out_of_range& e) {
81919       {
81920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81921       };
81922     } catch (std::exception& e) {
81923       {
81924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81925       };
81926     } catch (Dali::DaliException e) {
81927       {
81928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81929       };
81930     } catch (...) {
81931       {
81932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81933       };
81934     }
81935   }
81936
81937   jresult = (void *)result;
81938   return jresult;
81939 }
81940
81941
81942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81943   int jresult ;
81944   int result;
81945
81946   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81947   jresult = (int)result;
81948   return jresult;
81949 }
81950
81951
81952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81953   int jresult ;
81954   int result;
81955
81956   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81957   jresult = (int)result;
81958   return jresult;
81959 }
81960
81961
81962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81963   int jresult ;
81964   int result;
81965
81966   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81967   jresult = (int)result;
81968   return jresult;
81969 }
81970
81971
81972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81973   int jresult ;
81974   int result;
81975
81976   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81977   jresult = (int)result;
81978   return jresult;
81979 }
81980
81981
81982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81983   int jresult ;
81984   int result;
81985
81986   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81987   jresult = (int)result;
81988   return jresult;
81989 }
81990
81991
81992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81993   int jresult ;
81994   int result;
81995
81996   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81997   jresult = (int)result;
81998   return jresult;
81999 }
82000
82001
82002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
82003   int jresult ;
82004   int result;
82005
82006   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
82007   jresult = (int)result;
82008   return jresult;
82009 }
82010
82011
82012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
82013   int jresult ;
82014   int result;
82015
82016   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
82017   jresult = (int)result;
82018   return jresult;
82019 }
82020
82021
82022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
82023   int jresult ;
82024   int result;
82025
82026   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
82027   jresult = (int)result;
82028   return jresult;
82029 }
82030
82031
82032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
82033   int jresult ;
82034   int result;
82035
82036   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
82037   jresult = (int)result;
82038   return jresult;
82039 }
82040
82041
82042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
82043   int jresult ;
82044   int result;
82045
82046   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
82047   jresult = (int)result;
82048   return jresult;
82049 }
82050
82051
82052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
82053   int jresult ;
82054   int result;
82055
82056   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
82057   jresult = (int)result;
82058   return jresult;
82059 }
82060
82061
82062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
82063   int jresult ;
82064   int result;
82065
82066   result = (int)Dali::Toolkit::Slider::Property::MARKS;
82067   jresult = (int)result;
82068   return jresult;
82069 }
82070
82071
82072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
82073   int jresult ;
82074   int result;
82075
82076   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
82077   jresult = (int)result;
82078   return jresult;
82079 }
82080
82081
82082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
82083   int jresult ;
82084   int result;
82085
82086   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
82087   jresult = (int)result;
82088   return jresult;
82089 }
82090
82091
82092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
82093   void * jresult ;
82094   Dali::Toolkit::Slider::Property *result = 0 ;
82095
82096   {
82097     try {
82098       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
82099     } catch (std::out_of_range& e) {
82100       {
82101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82102       };
82103     } catch (std::exception& e) {
82104       {
82105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82106       };
82107     } catch (Dali::DaliException e) {
82108       {
82109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82110       };
82111     } catch (...) {
82112       {
82113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82114       };
82115     }
82116   }
82117
82118   jresult = (void *)result;
82119   return jresult;
82120 }
82121
82122
82123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
82124   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
82125
82126   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
82127   {
82128     try {
82129       delete arg1;
82130     } catch (std::out_of_range& e) {
82131       {
82132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82133       };
82134     } catch (std::exception& e) {
82135       {
82136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82137       };
82138     } catch (Dali::DaliException e) {
82139       {
82140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82141       };
82142     } catch (...) {
82143       {
82144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82145       };
82146     }
82147   }
82148
82149 }
82150
82151
82152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
82153   void * jresult ;
82154   Dali::Toolkit::Slider result;
82155
82156   {
82157     try {
82158       result = Dali::Toolkit::Slider::New();
82159     } catch (std::out_of_range& e) {
82160       {
82161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82162       };
82163     } catch (std::exception& e) {
82164       {
82165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82166       };
82167     } catch (Dali::DaliException e) {
82168       {
82169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82170       };
82171     } catch (...) {
82172       {
82173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82174       };
82175     }
82176   }
82177
82178   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82179   return jresult;
82180 }
82181
82182
82183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
82184   void * jresult ;
82185   Dali::Toolkit::Slider *result = 0 ;
82186
82187   {
82188     try {
82189       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
82190     } catch (std::out_of_range& e) {
82191       {
82192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82193       };
82194     } catch (std::exception& e) {
82195       {
82196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82197       };
82198     } catch (Dali::DaliException e) {
82199       {
82200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82201       };
82202     } catch (...) {
82203       {
82204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82205       };
82206     }
82207   }
82208
82209   jresult = (void *)result;
82210   return jresult;
82211 }
82212
82213
82214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
82215   void * jresult ;
82216   Dali::Toolkit::Slider *arg1 = 0 ;
82217   Dali::Toolkit::Slider *result = 0 ;
82218
82219   arg1 = (Dali::Toolkit::Slider *)jarg1;
82220   if (!arg1) {
82221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82222     return 0;
82223   }
82224   {
82225     try {
82226       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
82227     } catch (std::out_of_range& e) {
82228       {
82229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82230       };
82231     } catch (std::exception& e) {
82232       {
82233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82234       };
82235     } catch (Dali::DaliException e) {
82236       {
82237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82238       };
82239     } catch (...) {
82240       {
82241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82242       };
82243     }
82244   }
82245
82246   jresult = (void *)result;
82247   return jresult;
82248 }
82249
82250
82251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
82252   void * jresult ;
82253   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82254   Dali::Toolkit::Slider *arg2 = 0 ;
82255   Dali::Toolkit::Slider *result = 0 ;
82256
82257   arg1 = (Dali::Toolkit::Slider *)jarg1;
82258   arg2 = (Dali::Toolkit::Slider *)jarg2;
82259   if (!arg2) {
82260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82261     return 0;
82262   }
82263   {
82264     try {
82265       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
82266     } catch (std::out_of_range& e) {
82267       {
82268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82269       };
82270     } catch (std::exception& e) {
82271       {
82272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82273       };
82274     } catch (Dali::DaliException e) {
82275       {
82276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82277       };
82278     } catch (...) {
82279       {
82280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82281       };
82282     }
82283   }
82284
82285   jresult = (void *)result;
82286   return jresult;
82287 }
82288
82289
82290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
82291   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82292
82293   arg1 = (Dali::Toolkit::Slider *)jarg1;
82294   {
82295     try {
82296       delete arg1;
82297     } catch (std::out_of_range& e) {
82298       {
82299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82300       };
82301     } catch (std::exception& e) {
82302       {
82303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82304       };
82305     } catch (Dali::DaliException e) {
82306       {
82307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82308       };
82309     } catch (...) {
82310       {
82311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82312       };
82313     }
82314   }
82315
82316 }
82317
82318
82319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
82320   void * jresult ;
82321   Dali::BaseHandle arg1 ;
82322   Dali::BaseHandle *argp1 ;
82323   Dali::Toolkit::Slider result;
82324
82325   argp1 = (Dali::BaseHandle *)jarg1;
82326   if (!argp1) {
82327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82328     return 0;
82329   }
82330   arg1 = *argp1;
82331   {
82332     try {
82333       result = Dali::Toolkit::Slider::DownCast(arg1);
82334     } catch (std::out_of_range& e) {
82335       {
82336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82337       };
82338     } catch (std::exception& e) {
82339       {
82340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82341       };
82342     } catch (Dali::DaliException e) {
82343       {
82344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82345       };
82346     } catch (...) {
82347       {
82348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82349       };
82350     }
82351   }
82352
82353   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82354   return jresult;
82355 }
82356
82357
82358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
82359   void * jresult ;
82360   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82361   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82362
82363   arg1 = (Dali::Toolkit::Slider *)jarg1;
82364   {
82365     try {
82366       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82367     } catch (std::out_of_range& e) {
82368       {
82369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82370       };
82371     } catch (std::exception& e) {
82372       {
82373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82374       };
82375     } catch (Dali::DaliException e) {
82376       {
82377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82378       };
82379     } catch (...) {
82380       {
82381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82382       };
82383     }
82384   }
82385
82386   jresult = (void *)result;
82387   return jresult;
82388 }
82389
82390
82391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
82392   void * jresult ;
82393   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82394   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82395
82396   arg1 = (Dali::Toolkit::Slider *)jarg1;
82397   {
82398     try {
82399       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
82400     } catch (std::out_of_range& e) {
82401       {
82402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82403       };
82404     } catch (std::exception& e) {
82405       {
82406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82407       };
82408     } catch (Dali::DaliException e) {
82409       {
82410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82411       };
82412     } catch (...) {
82413       {
82414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82415       };
82416     }
82417   }
82418
82419   jresult = (void *)result;
82420   return jresult;
82421 }
82422
82423
82424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
82425   void * jresult ;
82426   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82427   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
82428
82429   arg1 = (Dali::Toolkit::Slider *)jarg1;
82430   {
82431     try {
82432       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
82433     } catch (std::out_of_range& e) {
82434       {
82435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82436       };
82437     } catch (std::exception& e) {
82438       {
82439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82440       };
82441     } catch (Dali::DaliException e) {
82442       {
82443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82444       };
82445     } catch (...) {
82446       {
82447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82448       };
82449     }
82450   }
82451
82452   jresult = (void *)result;
82453   return jresult;
82454 }
82455
82456
82457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82458   int jresult ;
82459   int result;
82460
82461   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82462   jresult = (int)result;
82463   return jresult;
82464 }
82465
82466
82467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82468   int jresult ;
82469   int result;
82470
82471   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82472   jresult = (int)result;
82473   return jresult;
82474 }
82475
82476
82477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82478   int jresult ;
82479   int result;
82480
82481   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82482   jresult = (int)result;
82483   return jresult;
82484 }
82485
82486
82487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82488   int jresult ;
82489   int result;
82490
82491   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82492   jresult = (int)result;
82493   return jresult;
82494 }
82495
82496
82497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
82498   int result;
82499
82500   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
82501
82502   return result;
82503 }
82504
82505
82506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82507   void * jresult ;
82508   Dali::Toolkit::VideoView::Property *result = 0 ;
82509
82510   {
82511     try {
82512       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82513     } catch (std::out_of_range& e) {
82514       {
82515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82516       };
82517     } catch (std::exception& e) {
82518       {
82519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82520       };
82521     } catch (Dali::DaliException e) {
82522       {
82523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82524       };
82525     } catch (...) {
82526       {
82527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82528       };
82529     }
82530   }
82531
82532   jresult = (void *)result;
82533   return jresult;
82534 }
82535
82536
82537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82538   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82539
82540   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82541   {
82542     try {
82543       delete arg1;
82544     } catch (std::out_of_range& e) {
82545       {
82546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82547       };
82548     } catch (std::exception& e) {
82549       {
82550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82551       };
82552     } catch (Dali::DaliException e) {
82553       {
82554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82555       };
82556     } catch (...) {
82557       {
82558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82559       };
82560     }
82561   }
82562
82563 }
82564
82565
82566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82567   void * jresult ;
82568   Dali::Toolkit::VideoView result;
82569
82570   {
82571     try {
82572       result = Dali::Toolkit::VideoView::New();
82573     } catch (std::out_of_range& e) {
82574       {
82575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82576       };
82577     } catch (std::exception& e) {
82578       {
82579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82580       };
82581     } catch (Dali::DaliException e) {
82582       {
82583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82584       };
82585     } catch (...) {
82586       {
82587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82588       };
82589     }
82590   }
82591
82592   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82593   return jresult;
82594 }
82595
82596
82597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82598   void * jresult ;
82599   std::string *arg1 = 0 ;
82600   Dali::Toolkit::VideoView result;
82601
82602   if (!jarg1) {
82603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82604     return 0;
82605   }
82606   std::string arg1_str(jarg1);
82607   arg1 = &arg1_str;
82608   {
82609     try {
82610       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82611     } catch (std::out_of_range& e) {
82612       {
82613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82614       };
82615     } catch (std::exception& e) {
82616       {
82617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82618       };
82619     } catch (Dali::DaliException e) {
82620       {
82621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82622       };
82623     } catch (...) {
82624       {
82625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82626       };
82627     }
82628   }
82629
82630   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82631
82632   //argout typemap for const std::string&
82633
82634   return jresult;
82635 }
82636
82637
82638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
82639   void * jresult ;
82640   Dali::Toolkit::VideoView result;
82641   {
82642     try {
82643       result = Dali::Toolkit::VideoView::New(swCodec);
82644     } catch (std::out_of_range& e) {
82645       {
82646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82647       };
82648     } catch (std::exception& e) {
82649       {
82650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82651       };
82652     } catch (Dali::DaliException e) {
82653       {
82654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82655       };
82656     } catch (...) {
82657       {
82658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82659       };
82660     }
82661   }
82662
82663   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82664
82665   //argout typemap for const std::string&
82666
82667   return jresult;
82668 }
82669
82670
82671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
82672   void * jresult ;
82673   std::string *arg1 = 0 ;
82674   Dali::Toolkit::VideoView result;
82675
82676   if (!jarg1) {
82677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82678     return 0;
82679   }
82680   std::string arg1_str(jarg1);
82681   arg1 = &arg1_str;
82682   {
82683     try {
82684       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
82685     } catch (std::out_of_range& e) {
82686       {
82687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82688       };
82689     } catch (std::exception& e) {
82690       {
82691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82692       };
82693     } catch (Dali::DaliException e) {
82694       {
82695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82696       };
82697     } catch (...) {
82698       {
82699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82700       };
82701     }
82702   }
82703
82704   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82705
82706   //argout typemap for const std::string&
82707
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82713   void * jresult ;
82714   Dali::Toolkit::VideoView *result = 0 ;
82715
82716   {
82717     try {
82718       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82719     } catch (std::out_of_range& e) {
82720       {
82721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82722       };
82723     } catch (std::exception& e) {
82724       {
82725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82726       };
82727     } catch (Dali::DaliException e) {
82728       {
82729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82730       };
82731     } catch (...) {
82732       {
82733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82734       };
82735     }
82736   }
82737
82738   jresult = (void *)result;
82739   return jresult;
82740 }
82741
82742
82743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82744   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82745
82746   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82747   {
82748     try {
82749       delete arg1;
82750     } catch (std::out_of_range& e) {
82751       {
82752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82753       };
82754     } catch (std::exception& e) {
82755       {
82756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82757       };
82758     } catch (Dali::DaliException e) {
82759       {
82760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82761       };
82762     } catch (...) {
82763       {
82764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82765       };
82766     }
82767   }
82768
82769 }
82770
82771
82772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82773   void * jresult ;
82774   Dali::Toolkit::VideoView *arg1 = 0 ;
82775   Dali::Toolkit::VideoView *result = 0 ;
82776
82777   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82778   if (!arg1) {
82779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82780     return 0;
82781   }
82782   {
82783     try {
82784       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82785     } catch (std::out_of_range& e) {
82786       {
82787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82788       };
82789     } catch (std::exception& e) {
82790       {
82791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82792       };
82793     } catch (Dali::DaliException e) {
82794       {
82795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82796       };
82797     } catch (...) {
82798       {
82799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82800       };
82801     }
82802   }
82803
82804   jresult = (void *)result;
82805   return jresult;
82806 }
82807
82808
82809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82810   void * jresult ;
82811   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82812   Dali::Toolkit::VideoView *arg2 = 0 ;
82813   Dali::Toolkit::VideoView *result = 0 ;
82814
82815   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82816   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82817   if (!arg2) {
82818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82819     return 0;
82820   }
82821   {
82822     try {
82823       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82824     } catch (std::out_of_range& e) {
82825       {
82826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82827       };
82828     } catch (std::exception& e) {
82829       {
82830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82831       };
82832     } catch (Dali::DaliException e) {
82833       {
82834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82835       };
82836     } catch (...) {
82837       {
82838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82839       };
82840     }
82841   }
82842
82843   jresult = (void *)result;
82844   return jresult;
82845 }
82846
82847
82848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82849   void * jresult ;
82850   Dali::BaseHandle arg1 ;
82851   Dali::BaseHandle *argp1 ;
82852   Dali::Toolkit::VideoView result;
82853
82854   argp1 = (Dali::BaseHandle *)jarg1;
82855   if (!argp1) {
82856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82857     return 0;
82858   }
82859   arg1 = *argp1;
82860   {
82861     try {
82862       result = Dali::Toolkit::VideoView::DownCast(arg1);
82863     } catch (std::out_of_range& e) {
82864       {
82865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82866       };
82867     } catch (std::exception& e) {
82868       {
82869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82870       };
82871     } catch (Dali::DaliException e) {
82872       {
82873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82874       };
82875     } catch (...) {
82876       {
82877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82878       };
82879     }
82880   }
82881
82882   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82883   return jresult;
82884 }
82885
82886
82887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82888   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82889
82890   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82891   {
82892     try {
82893       (arg1)->Play();
82894     } catch (std::out_of_range& e) {
82895       {
82896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82897       };
82898     } catch (std::exception& e) {
82899       {
82900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82901       };
82902     } catch (Dali::DaliException e) {
82903       {
82904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82905       };
82906     } catch (...) {
82907       {
82908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82909       };
82910     }
82911   }
82912
82913 }
82914
82915
82916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82917   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82918
82919   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82920   {
82921     try {
82922       (arg1)->Pause();
82923     } catch (std::out_of_range& e) {
82924       {
82925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82926       };
82927     } catch (std::exception& e) {
82928       {
82929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82930       };
82931     } catch (Dali::DaliException e) {
82932       {
82933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82934       };
82935     } catch (...) {
82936       {
82937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82938       };
82939     }
82940   }
82941
82942 }
82943
82944
82945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82946   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82947
82948   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82949   {
82950     try {
82951       (arg1)->Stop();
82952     } catch (std::out_of_range& e) {
82953       {
82954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82955       };
82956     } catch (std::exception& e) {
82957       {
82958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82959       };
82960     } catch (Dali::DaliException e) {
82961       {
82962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82963       };
82964     } catch (...) {
82965       {
82966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82967       };
82968     }
82969   }
82970
82971 }
82972
82973
82974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82975   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82976   int arg2 ;
82977
82978   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82979   arg2 = (int)jarg2;
82980   {
82981     try {
82982       (arg1)->Forward(arg2);
82983     } catch (std::out_of_range& e) {
82984       {
82985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82986       };
82987     } catch (std::exception& e) {
82988       {
82989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82990       };
82991     } catch (Dali::DaliException e) {
82992       {
82993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82994       };
82995     } catch (...) {
82996       {
82997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82998       };
82999     }
83000   }
83001
83002 }
83003
83004
83005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
83006   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
83007   int arg2 ;
83008
83009   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83010   arg2 = (int)jarg2;
83011   {
83012     try {
83013       (arg1)->Backward(arg2);
83014     } catch (std::out_of_range& e) {
83015       {
83016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83017       };
83018     } catch (std::exception& e) {
83019       {
83020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83021       };
83022     } catch (Dali::DaliException e) {
83023       {
83024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83025       };
83026     } catch (...) {
83027       {
83028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83029       };
83030     }
83031   }
83032
83033 }
83034
83035
83036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
83037   void * jresult ;
83038   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
83039   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
83040
83041   arg1 = (Dali::Toolkit::VideoView *)jarg1;
83042   {
83043     try {
83044       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
83045     } catch (std::out_of_range& e) {
83046       {
83047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83048       };
83049     } catch (std::exception& e) {
83050       {
83051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83052       };
83053     } catch (Dali::DaliException e) {
83054       {
83055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83056       };
83057     } catch (...) {
83058       {
83059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83060       };
83061     }
83062   }
83063
83064   jresult = (void *)result;
83065   return jresult;
83066 }
83067
83068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
83069 {
83070   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
83071   if( arg1 == nullptr )
83072   {
83073     DALI_LOG_ERROR("VideoView is nullptr!");
83074     return nullptr;
83075   }
83076   void * ret = nullptr;
83077   {
83078     try{
83079
83080       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
83081       ret = Dali::AnyCast< void * >( result );
83082
83083     } catch (std::out_of_range& e) {
83084       {
83085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83086       };
83087     } catch (std::exception& e) {
83088       {
83089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83090       };
83091     } catch (Dali::DaliException e) {
83092       {
83093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83094       };
83095     } catch (...) {
83096       {
83097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83098       };
83099     }
83100   }
83101   return ret;
83102 }
83103
83104
83105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
83106   int jresult ;
83107   int result;
83108
83109   result = (int)Dali::Toolkit::Popup::Property::TITLE;
83110   jresult = (int)result;
83111   return jresult;
83112 }
83113
83114
83115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
83116   int jresult ;
83117   int result;
83118
83119   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
83120   jresult = (int)result;
83121   return jresult;
83122 }
83123
83124
83125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
83126   int jresult ;
83127   int result;
83128
83129   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
83130   jresult = (int)result;
83131   return jresult;
83132 }
83133
83134
83135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
83136   int jresult ;
83137   int result;
83138
83139   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
83140   jresult = (int)result;
83141   return jresult;
83142 }
83143
83144
83145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
83146   int jresult ;
83147   int result;
83148
83149   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
83150   jresult = (int)result;
83151   return jresult;
83152 }
83153
83154
83155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
83156   int jresult ;
83157   int result;
83158
83159   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
83160   jresult = (int)result;
83161   return jresult;
83162 }
83163
83164
83165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
83166   int jresult ;
83167   int result;
83168
83169   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
83170   jresult = (int)result;
83171   return jresult;
83172 }
83173
83174
83175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
83176   int jresult ;
83177   int result;
83178
83179   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
83180   jresult = (int)result;
83181   return jresult;
83182 }
83183
83184
83185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
83186   int jresult ;
83187   int result;
83188
83189   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
83190   jresult = (int)result;
83191   return jresult;
83192 }
83193
83194
83195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
83196   int jresult ;
83197   int result;
83198
83199   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
83200   jresult = (int)result;
83201   return jresult;
83202 }
83203
83204
83205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
83206   int jresult ;
83207   int result;
83208
83209   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
83210   jresult = (int)result;
83211   return jresult;
83212 }
83213
83214
83215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
83216   int jresult ;
83217   int result;
83218
83219   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
83220   jresult = (int)result;
83221   return jresult;
83222 }
83223
83224
83225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
83226   int jresult ;
83227   int result;
83228
83229   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
83230   jresult = (int)result;
83231   return jresult;
83232 }
83233
83234
83235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
83236   int jresult ;
83237   int result;
83238
83239   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
83240   jresult = (int)result;
83241   return jresult;
83242 }
83243
83244
83245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
83246   int jresult ;
83247   int result;
83248
83249   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
83250   jresult = (int)result;
83251   return jresult;
83252 }
83253
83254
83255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
83256   int jresult ;
83257   int result;
83258
83259   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
83260   jresult = (int)result;
83261   return jresult;
83262 }
83263
83264
83265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
83266   int jresult ;
83267   int result;
83268
83269   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
83270   jresult = (int)result;
83271   return jresult;
83272 }
83273
83274
83275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
83276   int jresult ;
83277   int result;
83278
83279   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
83280   jresult = (int)result;
83281   return jresult;
83282 }
83283
83284
83285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
83286   int jresult ;
83287   int result;
83288
83289   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
83290   jresult = (int)result;
83291   return jresult;
83292 }
83293
83294
83295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
83296   int jresult ;
83297   int result;
83298
83299   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
83300   jresult = (int)result;
83301   return jresult;
83302 }
83303
83304
83305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
83306   int jresult ;
83307   int result;
83308
83309   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
83310   jresult = (int)result;
83311   return jresult;
83312 }
83313
83314
83315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
83316   void * jresult ;
83317   Dali::Toolkit::Popup::Property *result = 0 ;
83318
83319   {
83320     try {
83321       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
83322     } catch (std::out_of_range& e) {
83323       {
83324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83325       };
83326     } catch (std::exception& e) {
83327       {
83328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83329       };
83330     } catch (Dali::DaliException e) {
83331       {
83332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83333       };
83334     } catch (...) {
83335       {
83336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83337       };
83338     }
83339   }
83340
83341   jresult = (void *)result;
83342   return jresult;
83343 }
83344
83345
83346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
83347   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
83348
83349   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
83350   {
83351     try {
83352       delete arg1;
83353     } catch (std::out_of_range& e) {
83354       {
83355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83356       };
83357     } catch (std::exception& e) {
83358       {
83359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83360       };
83361     } catch (Dali::DaliException e) {
83362       {
83363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83364       };
83365     } catch (...) {
83366       {
83367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83368       };
83369     }
83370   }
83371
83372 }
83373
83374
83375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
83376   void * jresult ;
83377   Dali::Toolkit::Popup *result = 0 ;
83378
83379   {
83380     try {
83381       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
83382     } catch (std::out_of_range& e) {
83383       {
83384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83385       };
83386     } catch (std::exception& e) {
83387       {
83388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83389       };
83390     } catch (Dali::DaliException e) {
83391       {
83392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83393       };
83394     } catch (...) {
83395       {
83396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83397       };
83398     }
83399   }
83400
83401   jresult = (void *)result;
83402   return jresult;
83403 }
83404
83405
83406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
83407   void * jresult ;
83408   Dali::Toolkit::Popup result;
83409
83410   {
83411     try {
83412       result = Dali::Toolkit::Popup::New();
83413     } catch (std::out_of_range& e) {
83414       {
83415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83416       };
83417     } catch (std::exception& e) {
83418       {
83419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83420       };
83421     } catch (Dali::DaliException e) {
83422       {
83423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83424       };
83425     } catch (...) {
83426       {
83427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83428       };
83429     }
83430   }
83431
83432   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83433   return jresult;
83434 }
83435
83436
83437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
83438   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83439
83440   arg1 = (Dali::Toolkit::Popup *)jarg1;
83441   {
83442     try {
83443       delete arg1;
83444     } catch (std::out_of_range& e) {
83445       {
83446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83447       };
83448     } catch (std::exception& e) {
83449       {
83450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83451       };
83452     } catch (Dali::DaliException e) {
83453       {
83454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83455       };
83456     } catch (...) {
83457       {
83458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83459       };
83460     }
83461   }
83462
83463 }
83464
83465
83466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
83467   void * jresult ;
83468   Dali::Toolkit::Popup *arg1 = 0 ;
83469   Dali::Toolkit::Popup *result = 0 ;
83470
83471   arg1 = (Dali::Toolkit::Popup *)jarg1;
83472   if (!arg1) {
83473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83474     return 0;
83475   }
83476   {
83477     try {
83478       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
83479     } catch (std::out_of_range& e) {
83480       {
83481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83482       };
83483     } catch (std::exception& e) {
83484       {
83485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83486       };
83487     } catch (Dali::DaliException e) {
83488       {
83489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83490       };
83491     } catch (...) {
83492       {
83493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83494       };
83495     }
83496   }
83497
83498   jresult = (void *)result;
83499   return jresult;
83500 }
83501
83502
83503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
83504   void * jresult ;
83505   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83506   Dali::Toolkit::Popup *arg2 = 0 ;
83507   Dali::Toolkit::Popup *result = 0 ;
83508
83509   arg1 = (Dali::Toolkit::Popup *)jarg1;
83510   arg2 = (Dali::Toolkit::Popup *)jarg2;
83511   if (!arg2) {
83512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83513     return 0;
83514   }
83515   {
83516     try {
83517       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
83518     } catch (std::out_of_range& e) {
83519       {
83520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83521       };
83522     } catch (std::exception& e) {
83523       {
83524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83525       };
83526     } catch (Dali::DaliException e) {
83527       {
83528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83529       };
83530     } catch (...) {
83531       {
83532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83533       };
83534     }
83535   }
83536
83537   jresult = (void *)result;
83538   return jresult;
83539 }
83540
83541
83542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
83543   void * jresult ;
83544   Dali::BaseHandle arg1 ;
83545   Dali::BaseHandle *argp1 ;
83546   Dali::Toolkit::Popup result;
83547
83548   argp1 = (Dali::BaseHandle *)jarg1;
83549   if (!argp1) {
83550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83551     return 0;
83552   }
83553   arg1 = *argp1;
83554   {
83555     try {
83556       result = Dali::Toolkit::Popup::DownCast(arg1);
83557     } catch (std::out_of_range& e) {
83558       {
83559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83560       };
83561     } catch (std::exception& e) {
83562       {
83563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83564       };
83565     } catch (Dali::DaliException e) {
83566       {
83567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83568       };
83569     } catch (...) {
83570       {
83571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83572       };
83573     }
83574   }
83575
83576   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83577   return jresult;
83578 }
83579
83580
83581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83582   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83583   Dali::Actor arg2 ;
83584   Dali::Actor *argp2 ;
83585
83586   arg1 = (Dali::Toolkit::Popup *)jarg1;
83587   argp2 = (Dali::Actor *)jarg2;
83588   if (!argp2) {
83589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83590     return ;
83591   }
83592   arg2 = *argp2;
83593   {
83594     try {
83595       (arg1)->SetTitle(arg2);
83596     } catch (std::out_of_range& e) {
83597       {
83598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83599       };
83600     } catch (std::exception& e) {
83601       {
83602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83603       };
83604     } catch (Dali::DaliException e) {
83605       {
83606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83607       };
83608     } catch (...) {
83609       {
83610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83611       };
83612     }
83613   }
83614
83615 }
83616
83617
83618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83619   void * jresult ;
83620   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83621   Dali::Actor result;
83622
83623   arg1 = (Dali::Toolkit::Popup *)jarg1;
83624   {
83625     try {
83626       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83627     } catch (std::out_of_range& e) {
83628       {
83629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83630       };
83631     } catch (std::exception& e) {
83632       {
83633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83634       };
83635     } catch (Dali::DaliException e) {
83636       {
83637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83638       };
83639     } catch (...) {
83640       {
83641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83642       };
83643     }
83644   }
83645
83646   jresult = new Dali::Actor((const Dali::Actor &)result);
83647   return jresult;
83648 }
83649
83650
83651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83652   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83653   Dali::Actor arg2 ;
83654   Dali::Actor *argp2 ;
83655
83656   arg1 = (Dali::Toolkit::Popup *)jarg1;
83657   argp2 = (Dali::Actor *)jarg2;
83658   if (!argp2) {
83659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83660     return ;
83661   }
83662   arg2 = *argp2;
83663   {
83664     try {
83665       (arg1)->SetContent(arg2);
83666     } catch (std::out_of_range& e) {
83667       {
83668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83669       };
83670     } catch (std::exception& e) {
83671       {
83672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83673       };
83674     } catch (Dali::DaliException e) {
83675       {
83676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83677       };
83678     } catch (...) {
83679       {
83680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83681       };
83682     }
83683   }
83684
83685 }
83686
83687
83688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83689   void * jresult ;
83690   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83691   Dali::Actor result;
83692
83693   arg1 = (Dali::Toolkit::Popup *)jarg1;
83694   {
83695     try {
83696       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83697     } catch (std::out_of_range& e) {
83698       {
83699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83700       };
83701     } catch (std::exception& e) {
83702       {
83703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83704       };
83705     } catch (Dali::DaliException e) {
83706       {
83707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83708       };
83709     } catch (...) {
83710       {
83711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83712       };
83713     }
83714   }
83715
83716   jresult = new Dali::Actor((const Dali::Actor &)result);
83717   return jresult;
83718 }
83719
83720
83721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83722   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83723   Dali::Actor arg2 ;
83724   Dali::Actor *argp2 ;
83725
83726   arg1 = (Dali::Toolkit::Popup *)jarg1;
83727   argp2 = (Dali::Actor *)jarg2;
83728   if (!argp2) {
83729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83730     return ;
83731   }
83732   arg2 = *argp2;
83733   {
83734     try {
83735       (arg1)->SetFooter(arg2);
83736     } catch (std::out_of_range& e) {
83737       {
83738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83739       };
83740     } catch (std::exception& e) {
83741       {
83742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83743       };
83744     } catch (Dali::DaliException e) {
83745       {
83746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83747       };
83748     } catch (...) {
83749       {
83750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83751       };
83752     }
83753   }
83754
83755 }
83756
83757
83758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83759   void * jresult ;
83760   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83761   Dali::Actor result;
83762
83763   arg1 = (Dali::Toolkit::Popup *)jarg1;
83764   {
83765     try {
83766       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83767     } catch (std::out_of_range& e) {
83768       {
83769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83770       };
83771     } catch (std::exception& e) {
83772       {
83773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83774       };
83775     } catch (Dali::DaliException e) {
83776       {
83777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83778       };
83779     } catch (...) {
83780       {
83781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83782       };
83783     }
83784   }
83785
83786   jresult = new Dali::Actor((const Dali::Actor &)result);
83787   return jresult;
83788 }
83789
83790
83791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83792   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83793   Dali::Toolkit::Popup::DisplayState arg2 ;
83794
83795   arg1 = (Dali::Toolkit::Popup *)jarg1;
83796   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83797   {
83798     try {
83799       (arg1)->SetDisplayState(arg2);
83800     } catch (std::out_of_range& e) {
83801       {
83802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83803       };
83804     } catch (std::exception& e) {
83805       {
83806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83807       };
83808     } catch (Dali::DaliException e) {
83809       {
83810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83811       };
83812     } catch (...) {
83813       {
83814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83815       };
83816     }
83817   }
83818
83819 }
83820
83821
83822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83823   int jresult ;
83824   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83825   Dali::Toolkit::Popup::DisplayState result;
83826
83827   arg1 = (Dali::Toolkit::Popup *)jarg1;
83828   {
83829     try {
83830       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83831     } catch (std::out_of_range& e) {
83832       {
83833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83834       };
83835     } catch (std::exception& e) {
83836       {
83837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83838       };
83839     } catch (Dali::DaliException e) {
83840       {
83841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83842       };
83843     } catch (...) {
83844       {
83845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83846       };
83847     }
83848   }
83849
83850   jresult = (int)result;
83851   return jresult;
83852 }
83853
83854
83855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83856   void * jresult ;
83857   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83858   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83859
83860   arg1 = (Dali::Toolkit::Popup *)jarg1;
83861   {
83862     try {
83863       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83864     } catch (std::out_of_range& e) {
83865       {
83866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83867       };
83868     } catch (std::exception& e) {
83869       {
83870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83871       };
83872     } catch (Dali::DaliException e) {
83873       {
83874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83875       };
83876     } catch (...) {
83877       {
83878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83879       };
83880     }
83881   }
83882
83883   jresult = (void *)result;
83884   return jresult;
83885 }
83886
83887
83888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83889   void * jresult ;
83890   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83891   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83892
83893   arg1 = (Dali::Toolkit::Popup *)jarg1;
83894   {
83895     try {
83896       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83897     } catch (std::out_of_range& e) {
83898       {
83899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83900       };
83901     } catch (std::exception& e) {
83902       {
83903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83904       };
83905     } catch (Dali::DaliException e) {
83906       {
83907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83908       };
83909     } catch (...) {
83910       {
83911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83912       };
83913     }
83914   }
83915
83916   jresult = (void *)result;
83917   return jresult;
83918 }
83919
83920
83921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83922   void * jresult ;
83923   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83924   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83925
83926   arg1 = (Dali::Toolkit::Popup *)jarg1;
83927   {
83928     try {
83929       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83930     } catch (std::out_of_range& e) {
83931       {
83932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83933       };
83934     } catch (std::exception& e) {
83935       {
83936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83937       };
83938     } catch (Dali::DaliException e) {
83939       {
83940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83941       };
83942     } catch (...) {
83943       {
83944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83945       };
83946     }
83947   }
83948
83949   jresult = (void *)result;
83950   return jresult;
83951 }
83952
83953
83954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83955   void * jresult ;
83956   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83957   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83958
83959   arg1 = (Dali::Toolkit::Popup *)jarg1;
83960   {
83961     try {
83962       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83963     } catch (std::out_of_range& e) {
83964       {
83965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83966       };
83967     } catch (std::exception& e) {
83968       {
83969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83970       };
83971     } catch (Dali::DaliException e) {
83972       {
83973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83974       };
83975     } catch (...) {
83976       {
83977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83978       };
83979     }
83980   }
83981
83982   jresult = (void *)result;
83983   return jresult;
83984 }
83985
83986
83987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83988   void * jresult ;
83989   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83990   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83991
83992   arg1 = (Dali::Toolkit::Popup *)jarg1;
83993   {
83994     try {
83995       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83996     } catch (std::out_of_range& e) {
83997       {
83998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83999       };
84000     } catch (std::exception& e) {
84001       {
84002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84003       };
84004     } catch (Dali::DaliException e) {
84005       {
84006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84007       };
84008     } catch (...) {
84009       {
84010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84011       };
84012     }
84013   }
84014
84015   jresult = (void *)result;
84016   return jresult;
84017 }
84018
84019
84020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
84021   int jresult ;
84022   int result;
84023
84024   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
84025   jresult = (int)result;
84026   return jresult;
84027 }
84028
84029
84030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
84031   int jresult ;
84032   int result;
84033
84034   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
84035   jresult = (int)result;
84036   return jresult;
84037 }
84038
84039
84040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
84041   int jresult ;
84042   int result;
84043
84044   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
84045   jresult = (int)result;
84046   return jresult;
84047 }
84048
84049
84050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
84051   int jresult ;
84052   int result;
84053
84054   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
84055   jresult = (int)result;
84056   return jresult;
84057 }
84058
84059
84060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
84061   int jresult ;
84062   int result;
84063
84064   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
84065   jresult = (int)result;
84066   return jresult;
84067 }
84068
84069
84070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
84071   int jresult ;
84072   int result;
84073
84074   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
84075   jresult = (int)result;
84076   return jresult;
84077 }
84078
84079
84080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
84081   int jresult ;
84082   int result;
84083
84084   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
84085   jresult = (int)result;
84086   return jresult;
84087 }
84088
84089
84090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
84091   int jresult ;
84092   int result;
84093
84094   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
84095   jresult = (int)result;
84096   return jresult;
84097 }
84098
84099
84100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
84101   int jresult ;
84102   int result;
84103
84104   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
84105   jresult = (int)result;
84106   return jresult;
84107 }
84108
84109
84110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
84111   void * jresult ;
84112   Dali::Toolkit::ProgressBar::Property *result = 0 ;
84113
84114   {
84115     try {
84116       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
84117     } catch (std::out_of_range& e) {
84118       {
84119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84120       };
84121     } catch (std::exception& e) {
84122       {
84123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84124       };
84125     } catch (Dali::DaliException e) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84128       };
84129     } catch (...) {
84130       {
84131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84132       };
84133     }
84134   }
84135
84136   jresult = (void *)result;
84137   return jresult;
84138 }
84139
84140
84141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
84142   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
84143
84144   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
84145   {
84146     try {
84147       delete arg1;
84148     } catch (std::out_of_range& e) {
84149       {
84150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84151       };
84152     } catch (std::exception& e) {
84153       {
84154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84155       };
84156     } catch (Dali::DaliException e) {
84157       {
84158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84159       };
84160     } catch (...) {
84161       {
84162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84163       };
84164     }
84165   }
84166
84167 }
84168
84169
84170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
84171   void * jresult ;
84172   Dali::Toolkit::ProgressBar result;
84173
84174   {
84175     try {
84176       result = Dali::Toolkit::ProgressBar::New();
84177     } catch (std::out_of_range& e) {
84178       {
84179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84180       };
84181     } catch (std::exception& e) {
84182       {
84183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84184       };
84185     } catch (Dali::DaliException e) {
84186       {
84187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84188       };
84189     } catch (...) {
84190       {
84191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84192       };
84193     }
84194   }
84195
84196   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
84197   return jresult;
84198 }
84199
84200
84201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
84202   void * jresult ;
84203   Dali::Toolkit::ProgressBar *result = 0 ;
84204
84205   {
84206     try {
84207       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
84208     } catch (std::out_of_range& e) {
84209       {
84210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84211       };
84212     } catch (std::exception& e) {
84213       {
84214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84215       };
84216     } catch (Dali::DaliException e) {
84217       {
84218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84219       };
84220     } catch (...) {
84221       {
84222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84223       };
84224     }
84225   }
84226
84227   jresult = (void *)result;
84228   return jresult;
84229 }
84230
84231
84232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
84233   void * jresult ;
84234   Dali::Toolkit::ProgressBar *arg1 = 0 ;
84235   Dali::Toolkit::ProgressBar *result = 0 ;
84236
84237   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
84238   if (!arg1) {
84239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
84240     return 0;
84241   }
84242   {
84243     try {
84244       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
84245     } catch (std::out_of_range& e) {
84246       {
84247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84248       };
84249     } catch (std::exception& e) {
84250       {
84251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84252       };
84253     } catch (Dali::DaliException e) {
84254       {
84255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84256       };
84257     } catch (...) {
84258       {
84259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84260       };
84261     }
84262   }
84263
84264   jresult = (void *)result;
84265   return jresult;
84266 }
84267
84268
84269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
84270   void * jresult ;
84271   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
84272   Dali::Toolkit::ProgressBar *arg2 = 0 ;
84273   Dali::Toolkit::ProgressBar *result = 0 ;
84274
84275   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
84276   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
84277   if (!arg2) {
84278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
84279     return 0;
84280   }
84281   {
84282     try {
84283       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
84284     } catch (std::out_of_range& e) {
84285       {
84286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84287       };
84288     } catch (std::exception& e) {
84289       {
84290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84291       };
84292     } catch (Dali::DaliException e) {
84293       {
84294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84295       };
84296     } catch (...) {
84297       {
84298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84299       };
84300     }
84301   }
84302
84303   jresult = (void *)result;
84304   return jresult;
84305 }
84306
84307
84308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
84309   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
84310
84311   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
84312   {
84313     try {
84314       delete arg1;
84315     } catch (std::out_of_range& e) {
84316       {
84317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84318       };
84319     } catch (std::exception& e) {
84320       {
84321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84322       };
84323     } catch (Dali::DaliException e) {
84324       {
84325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84326       };
84327     } catch (...) {
84328       {
84329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84330       };
84331     }
84332   }
84333
84334 }
84335
84336
84337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
84338   void * jresult ;
84339   Dali::BaseHandle arg1 ;
84340   Dali::BaseHandle *argp1 ;
84341   Dali::Toolkit::ProgressBar result;
84342
84343   argp1 = (Dali::BaseHandle *)jarg1;
84344   if (!argp1) {
84345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84346     return 0;
84347   }
84348   arg1 = *argp1;
84349   {
84350     try {
84351       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
84352     } catch (std::out_of_range& e) {
84353       {
84354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84355       };
84356     } catch (std::exception& e) {
84357       {
84358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84359       };
84360     } catch (Dali::DaliException e) {
84361       {
84362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84363       };
84364     } catch (...) {
84365       {
84366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84367       };
84368     }
84369   }
84370
84371   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
84372   return jresult;
84373 }
84374
84375
84376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
84377   void * jresult ;
84378   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
84379   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
84380
84381   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
84382   {
84383     try {
84384       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
84385     } catch (std::out_of_range& e) {
84386       {
84387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84388       };
84389     } catch (std::exception& e) {
84390       {
84391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84392       };
84393     } catch (Dali::DaliException e) {
84394       {
84395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84396       };
84397     } catch (...) {
84398       {
84399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84400       };
84401     }
84402   }
84403
84404   jresult = (void *)result;
84405   return jresult;
84406 }
84407
84408
84409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
84410   void * jresult ;
84411   Dali::Toolkit::GaussianBlurView *result = 0 ;
84412
84413   {
84414     try {
84415       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
84416     } catch (std::out_of_range& e) {
84417       {
84418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84419       };
84420     } catch (std::exception& e) {
84421       {
84422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84423       };
84424     } catch (Dali::DaliException e) {
84425       {
84426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84427       };
84428     } catch (...) {
84429       {
84430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84431       };
84432     }
84433   }
84434
84435   jresult = (void *)result;
84436   return jresult;
84437 }
84438
84439
84440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
84441   void * jresult ;
84442   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
84443   Dali::Toolkit::GaussianBlurView *result = 0 ;
84444
84445   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84446   if (!arg1) {
84447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
84448     return 0;
84449   }
84450   {
84451     try {
84452       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
84453     } catch (std::out_of_range& e) {
84454       {
84455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84456       };
84457     } catch (std::exception& e) {
84458       {
84459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84460       };
84461     } catch (Dali::DaliException e) {
84462       {
84463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84464       };
84465     } catch (...) {
84466       {
84467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84468       };
84469     }
84470   }
84471
84472   jresult = (void *)result;
84473   return jresult;
84474 }
84475
84476
84477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
84478   void * jresult ;
84479   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84480   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
84481   Dali::Toolkit::GaussianBlurView *result = 0 ;
84482
84483   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84484   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
84485   if (!arg2) {
84486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
84487     return 0;
84488   }
84489   {
84490     try {
84491       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
84492     } catch (std::out_of_range& e) {
84493       {
84494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84495       };
84496     } catch (std::exception& e) {
84497       {
84498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84499       };
84500     } catch (Dali::DaliException e) {
84501       {
84502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84503       };
84504     } catch (...) {
84505       {
84506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84507       };
84508     }
84509   }
84510
84511   jresult = (void *)result;
84512   return jresult;
84513 }
84514
84515
84516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
84517   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84518
84519   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84520   {
84521     try {
84522       delete arg1;
84523     } catch (std::out_of_range& e) {
84524       {
84525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84526       };
84527     } catch (std::exception& e) {
84528       {
84529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84530       };
84531     } catch (Dali::DaliException e) {
84532       {
84533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84534       };
84535     } catch (...) {
84536       {
84537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84538       };
84539     }
84540   }
84541
84542 }
84543
84544
84545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
84546   void * jresult ;
84547   Dali::BaseHandle arg1 ;
84548   Dali::BaseHandle *argp1 ;
84549   Dali::Toolkit::GaussianBlurView result;
84550
84551   argp1 = (Dali::BaseHandle *)jarg1;
84552   if (!argp1) {
84553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84554     return 0;
84555   }
84556   arg1 = *argp1;
84557   {
84558     try {
84559       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
84560     } catch (std::out_of_range& e) {
84561       {
84562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84563       };
84564     } catch (std::exception& e) {
84565       {
84566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84567       };
84568     } catch (Dali::DaliException e) {
84569       {
84570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84571       };
84572     } catch (...) {
84573       {
84574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84575       };
84576     }
84577   }
84578
84579   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84580   return jresult;
84581 }
84582
84583
84584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
84585   void * jresult ;
84586   Dali::Toolkit::GaussianBlurView result;
84587
84588   {
84589     try {
84590       result = Dali::Toolkit::GaussianBlurView::New();
84591     } catch (std::out_of_range& e) {
84592       {
84593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84594       };
84595     } catch (std::exception& e) {
84596       {
84597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84598       };
84599     } catch (Dali::DaliException e) {
84600       {
84601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84602       };
84603     } catch (...) {
84604       {
84605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84606       };
84607     }
84608   }
84609
84610   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84611   return jresult;
84612 }
84613
84614
84615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
84616   void * jresult ;
84617   unsigned int arg1 ;
84618   float arg2 ;
84619   Dali::Pixel::Format arg3 ;
84620   float arg4 ;
84621   float arg5 ;
84622   bool arg6 ;
84623   Dali::Toolkit::GaussianBlurView result;
84624
84625   arg1 = (unsigned int)jarg1;
84626   arg2 = (float)jarg2;
84627   arg3 = (Dali::Pixel::Format)jarg3;
84628   arg4 = (float)jarg4;
84629   arg5 = (float)jarg5;
84630   arg6 = jarg6 ? true : false;
84631   {
84632     try {
84633       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
84634     } catch (std::out_of_range& e) {
84635       {
84636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84637       };
84638     } catch (std::exception& e) {
84639       {
84640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84641       };
84642     } catch (Dali::DaliException e) {
84643       {
84644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84645       };
84646     } catch (...) {
84647       {
84648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84649       };
84650     }
84651   }
84652
84653   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84654   return jresult;
84655 }
84656
84657
84658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84659   void * jresult ;
84660   unsigned int arg1 ;
84661   float arg2 ;
84662   Dali::Pixel::Format arg3 ;
84663   float arg4 ;
84664   float arg5 ;
84665   Dali::Toolkit::GaussianBlurView result;
84666
84667   arg1 = (unsigned int)jarg1;
84668   arg2 = (float)jarg2;
84669   arg3 = (Dali::Pixel::Format)jarg3;
84670   arg4 = (float)jarg4;
84671   arg5 = (float)jarg5;
84672   {
84673     try {
84674       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84675     } catch (std::out_of_range& e) {
84676       {
84677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84678       };
84679     } catch (std::exception& e) {
84680       {
84681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84682       };
84683     } catch (Dali::DaliException e) {
84684       {
84685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84686       };
84687     } catch (...) {
84688       {
84689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84690       };
84691     }
84692   }
84693
84694   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84695   return jresult;
84696 }
84697
84698
84699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84700   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84701   Dali::Actor arg2 ;
84702   Dali::Actor *argp2 ;
84703
84704   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84705   argp2 = (Dali::Actor *)jarg2;
84706   if (!argp2) {
84707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84708     return ;
84709   }
84710   arg2 = *argp2;
84711   {
84712     try {
84713       (arg1)->Add(arg2);
84714     } catch (std::out_of_range& e) {
84715       {
84716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84717       };
84718     } catch (std::exception& e) {
84719       {
84720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84721       };
84722     } catch (Dali::DaliException e) {
84723       {
84724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84725       };
84726     } catch (...) {
84727       {
84728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84729       };
84730     }
84731   }
84732
84733 }
84734
84735
84736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84737   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84738   Dali::Actor arg2 ;
84739   Dali::Actor *argp2 ;
84740
84741   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84742   argp2 = (Dali::Actor *)jarg2;
84743   if (!argp2) {
84744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84745     return ;
84746   }
84747   arg2 = *argp2;
84748   {
84749     try {
84750       (arg1)->Remove(arg2);
84751     } catch (std::out_of_range& e) {
84752       {
84753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84754       };
84755     } catch (std::exception& e) {
84756       {
84757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84758       };
84759     } catch (Dali::DaliException e) {
84760       {
84761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84762       };
84763     } catch (...) {
84764       {
84765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84766       };
84767     }
84768   }
84769
84770 }
84771
84772
84773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84774   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84775
84776   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84777   {
84778     try {
84779       (arg1)->Activate();
84780     } catch (std::out_of_range& e) {
84781       {
84782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84783       };
84784     } catch (std::exception& e) {
84785       {
84786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84787       };
84788     } catch (Dali::DaliException e) {
84789       {
84790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84791       };
84792     } catch (...) {
84793       {
84794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84795       };
84796     }
84797   }
84798
84799 }
84800
84801
84802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84803   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84804
84805   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84806   {
84807     try {
84808       (arg1)->ActivateOnce();
84809     } catch (std::out_of_range& e) {
84810       {
84811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84812       };
84813     } catch (std::exception& e) {
84814       {
84815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84816       };
84817     } catch (Dali::DaliException e) {
84818       {
84819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84820       };
84821     } catch (...) {
84822       {
84823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84824       };
84825     }
84826   }
84827
84828 }
84829
84830
84831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84832   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84833
84834   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84835   {
84836     try {
84837       (arg1)->Deactivate();
84838     } catch (std::out_of_range& e) {
84839       {
84840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84841       };
84842     } catch (std::exception& e) {
84843       {
84844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84845       };
84846     } catch (Dali::DaliException e) {
84847       {
84848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84849       };
84850     } catch (...) {
84851       {
84852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84853       };
84854     }
84855   }
84856
84857 }
84858
84859
84860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84861   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84862   Dali::Texture arg2 ;
84863   Dali::FrameBuffer arg3 ;
84864   Dali::Texture *argp2 ;
84865   Dali::FrameBuffer *argp3 ;
84866
84867   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84868   argp2 = (Dali::Texture *)jarg2;
84869   if (!argp2) {
84870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84871     return ;
84872   }
84873   arg2 = *argp2;
84874   argp3 = (Dali::FrameBuffer *)jarg3;
84875   if (!argp3) {
84876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84877     return ;
84878   }
84879   arg3 = *argp3;
84880   {
84881     try {
84882       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84883     } catch (std::out_of_range& e) {
84884       {
84885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84886       };
84887     } catch (std::exception& e) {
84888       {
84889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84890       };
84891     } catch (Dali::DaliException e) {
84892       {
84893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84894       };
84895     } catch (...) {
84896       {
84897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84898       };
84899     }
84900   }
84901
84902 }
84903
84904
84905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84906   int jresult ;
84907   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84908   Dali::Property::Index result;
84909
84910   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84911   {
84912     try {
84913       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84914     } catch (std::out_of_range& e) {
84915       {
84916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84917       };
84918     } catch (std::exception& e) {
84919       {
84920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84921       };
84922     } catch (Dali::DaliException e) {
84923       {
84924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84925       };
84926     } catch (...) {
84927       {
84928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84929       };
84930     }
84931   }
84932
84933   jresult = result;
84934   return jresult;
84935 }
84936
84937
84938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84939   void * jresult ;
84940   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84941   Dali::FrameBuffer result;
84942
84943   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84944   {
84945     try {
84946       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84947     } catch (std::out_of_range& e) {
84948       {
84949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84950       };
84951     } catch (std::exception& e) {
84952       {
84953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84954       };
84955     } catch (Dali::DaliException e) {
84956       {
84957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84958       };
84959     } catch (...) {
84960       {
84961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84962       };
84963     }
84964   }
84965
84966   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84967   return jresult;
84968 }
84969
84970
84971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84972   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84973   Dali::Vector4 *arg2 = 0 ;
84974
84975   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84976   arg2 = (Dali::Vector4 *)jarg2;
84977   if (!arg2) {
84978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84979     return ;
84980   }
84981   {
84982     try {
84983       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84984     } catch (std::out_of_range& e) {
84985       {
84986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84987       };
84988     } catch (std::exception& e) {
84989       {
84990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84991       };
84992     } catch (Dali::DaliException e) {
84993       {
84994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84995       };
84996     } catch (...) {
84997       {
84998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84999       };
85000     }
85001   }
85002
85003 }
85004
85005
85006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
85007   void * jresult ;
85008   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85009   Dali::Vector4 result;
85010
85011   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85012   {
85013     try {
85014       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
85015     } catch (std::out_of_range& e) {
85016       {
85017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85018       };
85019     } catch (std::exception& e) {
85020       {
85021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85022       };
85023     } catch (Dali::DaliException e) {
85024       {
85025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85026       };
85027     } catch (...) {
85028       {
85029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85030       };
85031     }
85032   }
85033
85034   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
85035   return jresult;
85036 }
85037
85038
85039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
85040   void * jresult ;
85041   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
85042   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
85043
85044   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
85045   {
85046     try {
85047       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
85048     } catch (std::out_of_range& e) {
85049       {
85050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85051       };
85052     } catch (std::exception& e) {
85053       {
85054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (Dali::DaliException e) {
85057       {
85058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85059       };
85060     } catch (...) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85063       };
85064     }
85065   }
85066
85067   jresult = (void *)result;
85068   return jresult;
85069 }
85070
85071
85072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
85073   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
85074
85075   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85076   {
85077     try {
85078       delete arg1;
85079     } catch (std::out_of_range& e) {
85080       {
85081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85082       };
85083     } catch (std::exception& e) {
85084       {
85085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85086       };
85087     } catch (Dali::DaliException e) {
85088       {
85089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85090       };
85091     } catch (...) {
85092       {
85093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85094       };
85095     }
85096   }
85097
85098 }
85099
85100
85101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
85102   unsigned int jresult ;
85103   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
85104   unsigned int result;
85105
85106   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85107   {
85108     try {
85109       result = (unsigned int)(arg1)->GetNumberOfPages();
85110     } catch (std::out_of_range& e) {
85111       {
85112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85113       };
85114     } catch (std::exception& e) {
85115       {
85116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85117       };
85118     } catch (Dali::DaliException e) {
85119       {
85120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85121       };
85122     } catch (...) {
85123       {
85124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85125       };
85126     }
85127   }
85128
85129   jresult = result;
85130   return jresult;
85131 }
85132
85133
85134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
85135   void * jresult ;
85136   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
85137   unsigned int arg2 ;
85138   Dali::Texture result;
85139
85140   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85141   arg2 = (unsigned int)jarg2;
85142   {
85143     try {
85144       result = (arg1)->NewPage(arg2);
85145     } catch (std::out_of_range& e) {
85146       {
85147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85148       };
85149     } catch (std::exception& e) {
85150       {
85151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85152       };
85153     } catch (Dali::DaliException e) {
85154       {
85155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85156       };
85157     } catch (...) {
85158       {
85159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85160       };
85161     }
85162   }
85163
85164   jresult = new Dali::Texture((const Dali::Texture &)result);
85165   return jresult;
85166 }
85167
85168
85169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
85170   int jresult ;
85171   int result;
85172
85173   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
85174   jresult = (int)result;
85175   return jresult;
85176 }
85177
85178
85179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
85180   int jresult ;
85181   int result;
85182
85183   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
85184   jresult = (int)result;
85185   return jresult;
85186 }
85187
85188
85189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
85190   int jresult ;
85191   int result;
85192
85193   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
85194   jresult = (int)result;
85195   return jresult;
85196 }
85197
85198
85199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
85200   void * jresult ;
85201   Dali::Toolkit::PageTurnView::Property *result = 0 ;
85202
85203   {
85204     try {
85205       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
85206     } catch (std::out_of_range& e) {
85207       {
85208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85209       };
85210     } catch (std::exception& e) {
85211       {
85212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85213       };
85214     } catch (Dali::DaliException e) {
85215       {
85216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85217       };
85218     } catch (...) {
85219       {
85220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85221       };
85222     }
85223   }
85224
85225   jresult = (void *)result;
85226   return jresult;
85227 }
85228
85229
85230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
85231   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
85232
85233   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
85234   {
85235     try {
85236       delete arg1;
85237     } catch (std::out_of_range& e) {
85238       {
85239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85240       };
85241     } catch (std::exception& e) {
85242       {
85243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85244       };
85245     } catch (Dali::DaliException e) {
85246       {
85247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85248       };
85249     } catch (...) {
85250       {
85251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85252       };
85253     }
85254   }
85255
85256 }
85257
85258
85259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
85260   void * jresult ;
85261   Dali::Toolkit::PageTurnView *result = 0 ;
85262
85263   {
85264     try {
85265       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
85266     } catch (std::out_of_range& e) {
85267       {
85268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85269       };
85270     } catch (std::exception& e) {
85271       {
85272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85273       };
85274     } catch (Dali::DaliException e) {
85275       {
85276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85277       };
85278     } catch (...) {
85279       {
85280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85281       };
85282     }
85283   }
85284
85285   jresult = (void *)result;
85286   return jresult;
85287 }
85288
85289
85290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
85291   void * jresult ;
85292   Dali::Toolkit::PageTurnView *arg1 = 0 ;
85293   Dali::Toolkit::PageTurnView *result = 0 ;
85294
85295   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85296   if (!arg1) {
85297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
85298     return 0;
85299   }
85300   {
85301     try {
85302       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
85303     } catch (std::out_of_range& e) {
85304       {
85305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85306       };
85307     } catch (std::exception& e) {
85308       {
85309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85310       };
85311     } catch (Dali::DaliException e) {
85312       {
85313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85314       };
85315     } catch (...) {
85316       {
85317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85318       };
85319     }
85320   }
85321
85322   jresult = (void *)result;
85323   return jresult;
85324 }
85325
85326
85327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
85328   void * jresult ;
85329   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85330   Dali::Toolkit::PageTurnView *arg2 = 0 ;
85331   Dali::Toolkit::PageTurnView *result = 0 ;
85332
85333   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85334   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
85335   if (!arg2) {
85336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
85337     return 0;
85338   }
85339   {
85340     try {
85341       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
85342     } catch (std::out_of_range& e) {
85343       {
85344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85345       };
85346     } catch (std::exception& e) {
85347       {
85348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85349       };
85350     } catch (Dali::DaliException e) {
85351       {
85352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85353       };
85354     } catch (...) {
85355       {
85356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85357       };
85358     }
85359   }
85360
85361   jresult = (void *)result;
85362   return jresult;
85363 }
85364
85365
85366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
85367   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85368
85369   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85370   {
85371     try {
85372       delete arg1;
85373     } catch (std::out_of_range& e) {
85374       {
85375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85376       };
85377     } catch (std::exception& e) {
85378       {
85379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85380       };
85381     } catch (Dali::DaliException e) {
85382       {
85383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85384       };
85385     } catch (...) {
85386       {
85387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85388       };
85389     }
85390   }
85391
85392 }
85393
85394
85395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
85396   void * jresult ;
85397   Dali::BaseHandle arg1 ;
85398   Dali::BaseHandle *argp1 ;
85399   Dali::Toolkit::PageTurnView result;
85400
85401   argp1 = (Dali::BaseHandle *)jarg1;
85402   if (!argp1) {
85403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85404     return 0;
85405   }
85406   arg1 = *argp1;
85407   {
85408     try {
85409       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
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 = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
85430   return jresult;
85431 }
85432
85433
85434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
85435   void * jresult ;
85436   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85437   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
85438
85439   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85440   {
85441     try {
85442       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
85443     } catch (std::out_of_range& e) {
85444       {
85445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85446       };
85447     } catch (std::exception& e) {
85448       {
85449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85450       };
85451     } catch (Dali::DaliException e) {
85452       {
85453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85454       };
85455     } catch (...) {
85456       {
85457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85458       };
85459     }
85460   }
85461
85462   jresult = (void *)result;
85463   return jresult;
85464 }
85465
85466
85467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
85468   void * jresult ;
85469   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85470   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
85471
85472   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85473   {
85474     try {
85475       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
85476     } catch (std::out_of_range& e) {
85477       {
85478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85479       };
85480     } catch (std::exception& e) {
85481       {
85482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85483       };
85484     } catch (Dali::DaliException e) {
85485       {
85486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85487       };
85488     } catch (...) {
85489       {
85490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85491       };
85492     }
85493   }
85494
85495   jresult = (void *)result;
85496   return jresult;
85497 }
85498
85499
85500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
85501   void * jresult ;
85502   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85503   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
85504
85505   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85506   {
85507     try {
85508       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
85509     } catch (std::out_of_range& e) {
85510       {
85511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85512       };
85513     } catch (std::exception& e) {
85514       {
85515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85516       };
85517     } catch (Dali::DaliException e) {
85518       {
85519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85520       };
85521     } catch (...) {
85522       {
85523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85524       };
85525     }
85526   }
85527
85528   jresult = (void *)result;
85529   return jresult;
85530 }
85531
85532
85533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
85534   void * jresult ;
85535   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85536   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
85537
85538   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85539   {
85540     try {
85541       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
85542     } catch (std::out_of_range& e) {
85543       {
85544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85545       };
85546     } catch (std::exception& e) {
85547       {
85548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85549       };
85550     } catch (Dali::DaliException e) {
85551       {
85552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85553       };
85554     } catch (...) {
85555       {
85556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85557       };
85558     }
85559   }
85560
85561   jresult = (void *)result;
85562   return jresult;
85563 }
85564
85565
85566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
85567   void * jresult ;
85568   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85569
85570   {
85571     try {
85572       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
85573     } catch (std::out_of_range& e) {
85574       {
85575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85576       };
85577     } catch (std::exception& e) {
85578       {
85579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85580       };
85581     } catch (Dali::DaliException e) {
85582       {
85583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85584       };
85585     } catch (...) {
85586       {
85587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85588       };
85589     }
85590   }
85591
85592   jresult = (void *)result;
85593   return jresult;
85594 }
85595
85596
85597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
85598   void * jresult ;
85599   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
85600   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85601
85602   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85603   if (!arg1) {
85604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85605     return 0;
85606   }
85607   {
85608     try {
85609       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
85610     } catch (std::out_of_range& e) {
85611       {
85612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85613       };
85614     } catch (std::exception& e) {
85615       {
85616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85617       };
85618     } catch (Dali::DaliException e) {
85619       {
85620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85621       };
85622     } catch (...) {
85623       {
85624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85625       };
85626     }
85627   }
85628
85629   jresult = (void *)result;
85630   return jresult;
85631 }
85632
85633
85634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
85635   void * jresult ;
85636   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85637   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
85638   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85639
85640   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85641   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
85642   if (!arg2) {
85643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85644     return 0;
85645   }
85646   {
85647     try {
85648       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
85649     } catch (std::out_of_range& e) {
85650       {
85651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85652       };
85653     } catch (std::exception& e) {
85654       {
85655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85656       };
85657     } catch (Dali::DaliException e) {
85658       {
85659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85660       };
85661     } catch (...) {
85662       {
85663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85664       };
85665     }
85666   }
85667
85668   jresult = (void *)result;
85669   return jresult;
85670 }
85671
85672
85673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
85674   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85675
85676   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85677   {
85678     try {
85679       delete arg1;
85680     } catch (std::out_of_range& e) {
85681       {
85682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85683       };
85684     } catch (std::exception& e) {
85685       {
85686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85687       };
85688     } catch (Dali::DaliException e) {
85689       {
85690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85691       };
85692     } catch (...) {
85693       {
85694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85695       };
85696     }
85697   }
85698
85699 }
85700
85701
85702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
85703   void * jresult ;
85704   Dali::Toolkit::PageFactory *arg1 = 0 ;
85705   Dali::Vector2 *arg2 = 0 ;
85706   Dali::Toolkit::PageTurnLandscapeView result;
85707
85708   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85709   if (!arg1) {
85710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85711     return 0;
85712   }
85713   arg2 = (Dali::Vector2 *)jarg2;
85714   if (!arg2) {
85715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85716     return 0;
85717   }
85718   {
85719     try {
85720       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
85721     } catch (std::out_of_range& e) {
85722       {
85723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85724       };
85725     } catch (std::exception& e) {
85726       {
85727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85728       };
85729     } catch (Dali::DaliException e) {
85730       {
85731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85732       };
85733     } catch (...) {
85734       {
85735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85736       };
85737     }
85738   }
85739
85740   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85741   return jresult;
85742 }
85743
85744
85745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85746   void * jresult ;
85747   Dali::BaseHandle arg1 ;
85748   Dali::BaseHandle *argp1 ;
85749   Dali::Toolkit::PageTurnLandscapeView result;
85750
85751   argp1 = (Dali::BaseHandle *)jarg1;
85752   if (!argp1) {
85753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85754     return 0;
85755   }
85756   arg1 = *argp1;
85757   {
85758     try {
85759       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85760     } catch (std::out_of_range& e) {
85761       {
85762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85763       };
85764     } catch (std::exception& e) {
85765       {
85766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85767       };
85768     } catch (Dali::DaliException e) {
85769       {
85770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85771       };
85772     } catch (...) {
85773       {
85774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85775       };
85776     }
85777   }
85778
85779   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85780   return jresult;
85781 }
85782
85783
85784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85785   void * jresult ;
85786   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85787
85788   {
85789     try {
85790       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85791     } catch (std::out_of_range& e) {
85792       {
85793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85794       };
85795     } catch (std::exception& e) {
85796       {
85797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85798       };
85799     } catch (Dali::DaliException e) {
85800       {
85801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85802       };
85803     } catch (...) {
85804       {
85805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85806       };
85807     }
85808   }
85809
85810   jresult = (void *)result;
85811   return jresult;
85812 }
85813
85814
85815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85816   void * jresult ;
85817   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85818   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85819
85820   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85821   if (!arg1) {
85822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85823     return 0;
85824   }
85825   {
85826     try {
85827       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85828     } catch (std::out_of_range& e) {
85829       {
85830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85831       };
85832     } catch (std::exception& e) {
85833       {
85834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85835       };
85836     } catch (Dali::DaliException e) {
85837       {
85838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85839       };
85840     } catch (...) {
85841       {
85842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85843       };
85844     }
85845   }
85846
85847   jresult = (void *)result;
85848   return jresult;
85849 }
85850
85851
85852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85853   void * jresult ;
85854   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85855   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85856   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85857
85858   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85859   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85860   if (!arg2) {
85861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85862     return 0;
85863   }
85864   {
85865     try {
85866       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85867     } catch (std::out_of_range& e) {
85868       {
85869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85870       };
85871     } catch (std::exception& e) {
85872       {
85873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85874       };
85875     } catch (Dali::DaliException e) {
85876       {
85877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85878       };
85879     } catch (...) {
85880       {
85881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85882       };
85883     }
85884   }
85885
85886   jresult = (void *)result;
85887   return jresult;
85888 }
85889
85890
85891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85892   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85893
85894   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85895   {
85896     try {
85897       delete arg1;
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 void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85921   void * jresult ;
85922   Dali::Toolkit::PageFactory *arg1 = 0 ;
85923   Dali::Vector2 *arg2 = 0 ;
85924   Dali::Toolkit::PageTurnPortraitView result;
85925
85926   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85927   if (!arg1) {
85928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85929     return 0;
85930   }
85931   arg2 = (Dali::Vector2 *)jarg2;
85932   if (!arg2) {
85933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85934     return 0;
85935   }
85936   {
85937     try {
85938       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85939     } catch (std::out_of_range& e) {
85940       {
85941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85942       };
85943     } catch (std::exception& e) {
85944       {
85945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85946       };
85947     } catch (Dali::DaliException e) {
85948       {
85949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85950       };
85951     } catch (...) {
85952       {
85953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85954       };
85955     }
85956   }
85957
85958   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85959   return jresult;
85960 }
85961
85962
85963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85964   void * jresult ;
85965   Dali::BaseHandle arg1 ;
85966   Dali::BaseHandle *argp1 ;
85967   Dali::Toolkit::PageTurnPortraitView result;
85968
85969   argp1 = (Dali::BaseHandle *)jarg1;
85970   if (!argp1) {
85971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85972     return 0;
85973   }
85974   arg1 = *argp1;
85975   {
85976     try {
85977       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85978     } catch (std::out_of_range& e) {
85979       {
85980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85981       };
85982     } catch (std::exception& e) {
85983       {
85984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85985       };
85986     } catch (Dali::DaliException e) {
85987       {
85988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85989       };
85990     } catch (...) {
85991       {
85992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85993       };
85994     }
85995   }
85996
85997   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85998   return jresult;
85999 }
86000
86001
86002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
86003   int jresult ;
86004   int result;
86005
86006   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
86007   jresult = (int)result;
86008   return jresult;
86009 }
86010
86011
86012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
86013   int jresult ;
86014   int result;
86015
86016   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
86017   jresult = (int)result;
86018   return jresult;
86019 }
86020
86021
86022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
86023   int jresult ;
86024   int result;
86025
86026   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
86027   jresult = (int)result;
86028   return jresult;
86029 }
86030
86031
86032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
86033   void * jresult ;
86034   Dali::Toolkit::ToggleButton::Property *result = 0 ;
86035
86036   {
86037     try {
86038       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
86039     } catch (std::out_of_range& e) {
86040       {
86041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86042       };
86043     } catch (std::exception& e) {
86044       {
86045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86046       };
86047     } catch (Dali::DaliException e) {
86048       {
86049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86050       };
86051     } catch (...) {
86052       {
86053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86054       };
86055     }
86056   }
86057
86058   jresult = (void *)result;
86059   return jresult;
86060 }
86061
86062
86063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
86064   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
86065
86066   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
86067   {
86068     try {
86069       delete arg1;
86070     } catch (std::out_of_range& e) {
86071       {
86072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86073       };
86074     } catch (std::exception& e) {
86075       {
86076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86077       };
86078     } catch (Dali::DaliException e) {
86079       {
86080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86081       };
86082     } catch (...) {
86083       {
86084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86085       };
86086     }
86087   }
86088
86089 }
86090
86091
86092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
86093   void * jresult ;
86094   Dali::Toolkit::ToggleButton *result = 0 ;
86095
86096   {
86097     try {
86098       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
86099     } catch (std::out_of_range& e) {
86100       {
86101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86102       };
86103     } catch (std::exception& e) {
86104       {
86105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86106       };
86107     } catch (Dali::DaliException e) {
86108       {
86109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86110       };
86111     } catch (...) {
86112       {
86113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86114       };
86115     }
86116   }
86117
86118   jresult = (void *)result;
86119   return jresult;
86120 }
86121
86122
86123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
86124   void * jresult ;
86125   Dali::Toolkit::ToggleButton *arg1 = 0 ;
86126   Dali::Toolkit::ToggleButton *result = 0 ;
86127
86128   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
86129   if (!arg1) {
86130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
86131     return 0;
86132   }
86133   {
86134     try {
86135       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
86136     } catch (std::out_of_range& e) {
86137       {
86138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86139       };
86140     } catch (std::exception& e) {
86141       {
86142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86143       };
86144     } catch (Dali::DaliException e) {
86145       {
86146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86147       };
86148     } catch (...) {
86149       {
86150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86151       };
86152     }
86153   }
86154
86155   jresult = (void *)result;
86156   return jresult;
86157 }
86158
86159
86160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
86161   void * jresult ;
86162   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
86163   Dali::Toolkit::ToggleButton *arg2 = 0 ;
86164   Dali::Toolkit::ToggleButton *result = 0 ;
86165
86166   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
86167   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
86168   if (!arg2) {
86169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
86170     return 0;
86171   }
86172   {
86173     try {
86174       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
86175     } catch (std::out_of_range& e) {
86176       {
86177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86178       };
86179     } catch (std::exception& e) {
86180       {
86181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86182       };
86183     } catch (Dali::DaliException e) {
86184       {
86185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86186       };
86187     } catch (...) {
86188       {
86189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86190       };
86191     }
86192   }
86193
86194   jresult = (void *)result;
86195   return jresult;
86196 }
86197
86198
86199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
86200   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
86201
86202   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
86203   {
86204     try {
86205       delete arg1;
86206     } catch (std::out_of_range& e) {
86207       {
86208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86209       };
86210     } catch (std::exception& e) {
86211       {
86212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86213       };
86214     } catch (Dali::DaliException e) {
86215       {
86216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86217       };
86218     } catch (...) {
86219       {
86220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86221       };
86222     }
86223   }
86224
86225 }
86226
86227
86228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
86229   void * jresult ;
86230   Dali::Toolkit::ToggleButton result;
86231
86232   {
86233     try {
86234       result = Dali::Toolkit::ToggleButton::New();
86235     } catch (std::out_of_range& e) {
86236       {
86237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86238       };
86239     } catch (std::exception& e) {
86240       {
86241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86242       };
86243     } catch (Dali::DaliException e) {
86244       {
86245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86246       };
86247     } catch (...) {
86248       {
86249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86250       };
86251     }
86252   }
86253
86254   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
86255   return jresult;
86256 }
86257
86258
86259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
86260   void * jresult ;
86261   Dali::BaseHandle arg1 ;
86262   Dali::BaseHandle *argp1 ;
86263   Dali::Toolkit::ToggleButton result;
86264
86265   argp1 = (Dali::BaseHandle *)jarg1;
86266   if (!argp1) {
86267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86268     return 0;
86269   }
86270   arg1 = *argp1;
86271   {
86272     try {
86273       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
86274     } catch (std::out_of_range& e) {
86275       {
86276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86277       };
86278     } catch (std::exception& e) {
86279       {
86280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86281       };
86282     } catch (Dali::DaliException e) {
86283       {
86284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86285       };
86286     } catch (...) {
86287       {
86288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86289       };
86290     }
86291   }
86292
86293   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
86294   return jresult;
86295 }
86296
86297
86298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
86299   void * jresult ;
86300   Dali::Toolkit::Visual::Base *result = 0 ;
86301
86302   {
86303     try {
86304       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
86305     } catch (std::out_of_range& e) {
86306       {
86307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86308       };
86309     } catch (std::exception& e) {
86310       {
86311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86312       };
86313     } catch (Dali::DaliException e) {
86314       {
86315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86316       };
86317     } catch (...) {
86318       {
86319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86320       };
86321     }
86322   }
86323
86324   jresult = (void *)result;
86325   return jresult;
86326 }
86327
86328
86329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
86330   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86331
86332   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86333   {
86334     try {
86335       delete arg1;
86336     } catch (std::out_of_range& e) {
86337       {
86338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86339       };
86340     } catch (std::exception& e) {
86341       {
86342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86343       };
86344     } catch (Dali::DaliException e) {
86345       {
86346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86347       };
86348     } catch (...) {
86349       {
86350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86351       };
86352     }
86353   }
86354
86355 }
86356
86357
86358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
86359   void * jresult ;
86360   Dali::Toolkit::Visual::Base *arg1 = 0 ;
86361   Dali::Toolkit::Visual::Base *result = 0 ;
86362
86363   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86364   if (!arg1) {
86365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
86366     return 0;
86367   }
86368   {
86369     try {
86370       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
86371     } catch (std::out_of_range& e) {
86372       {
86373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86374       };
86375     } catch (std::exception& e) {
86376       {
86377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86378       };
86379     } catch (Dali::DaliException e) {
86380       {
86381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86382       };
86383     } catch (...) {
86384       {
86385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86386       };
86387     }
86388   }
86389
86390   jresult = (void *)result;
86391   return jresult;
86392 }
86393
86394
86395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
86396   void * jresult ;
86397   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86398   Dali::Toolkit::Visual::Base *arg2 = 0 ;
86399   Dali::Toolkit::Visual::Base *result = 0 ;
86400
86401   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86402   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
86403   if (!arg2) {
86404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
86405     return 0;
86406   }
86407   {
86408     try {
86409       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
86410     } catch (std::out_of_range& e) {
86411       {
86412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86413       };
86414     } catch (std::exception& e) {
86415       {
86416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86417       };
86418     } catch (Dali::DaliException e) {
86419       {
86420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86421       };
86422     } catch (...) {
86423       {
86424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86425       };
86426     }
86427   }
86428
86429   jresult = (void *)result;
86430   return jresult;
86431 }
86432
86433
86434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
86435   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86436   std::string *arg2 = 0 ;
86437
86438   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86439   if (!jarg2) {
86440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86441     return ;
86442   }
86443   std::string arg2_str(jarg2);
86444   arg2 = &arg2_str;
86445   {
86446     try {
86447       (arg1)->SetName((std::string const &)*arg2);
86448     } catch (std::out_of_range& e) {
86449       {
86450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86451       };
86452     } catch (std::exception& e) {
86453       {
86454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86455       };
86456     } catch (Dali::DaliException e) {
86457       {
86458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86459       };
86460     } catch (...) {
86461       {
86462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86463       };
86464     }
86465   }
86466
86467
86468   //argout typemap for const std::string&
86469
86470 }
86471
86472
86473 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
86474   char * jresult ;
86475   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86476   std::string *result = 0 ;
86477
86478   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86479   {
86480     try {
86481       result = (std::string *) &(arg1)->GetName();
86482     } catch (std::out_of_range& e) {
86483       {
86484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86485       };
86486     } catch (std::exception& e) {
86487       {
86488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86489       };
86490     } catch (Dali::DaliException e) {
86491       {
86492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86493       };
86494     } catch (...) {
86495       {
86496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86497       };
86498     }
86499   }
86500
86501   jresult = SWIG_csharp_string_callback(result->c_str());
86502   return jresult;
86503 }
86504
86505
86506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
86507   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86508   Dali::Property::Map *arg2 = 0 ;
86509   Dali::Size arg3 ;
86510   Dali::Size *argp3 ;
86511
86512   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86513   arg2 = (Dali::Property::Map *)jarg2;
86514   if (!arg2) {
86515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86516     return ;
86517   }
86518   argp3 = (Dali::Size *)jarg3;
86519   if (!argp3) {
86520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
86521     return ;
86522   }
86523   arg3 = *argp3;
86524   {
86525     try {
86526       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
86527     } catch (std::out_of_range& e) {
86528       {
86529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86530       };
86531     } catch (std::exception& e) {
86532       {
86533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86534       };
86535     } catch (Dali::DaliException e) {
86536       {
86537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86538       };
86539     } catch (...) {
86540       {
86541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86542       };
86543     }
86544   }
86545
86546 }
86547
86548
86549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
86550   float jresult ;
86551   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86552   float arg2 ;
86553   float result;
86554
86555   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86556   arg2 = (float)jarg2;
86557   {
86558     try {
86559       result = (float)(arg1)->GetHeightForWidth(arg2);
86560     } catch (std::out_of_range& e) {
86561       {
86562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86563       };
86564     } catch (std::exception& e) {
86565       {
86566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86567       };
86568     } catch (Dali::DaliException e) {
86569       {
86570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86571       };
86572     } catch (...) {
86573       {
86574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86575       };
86576     }
86577   }
86578
86579   jresult = result;
86580   return jresult;
86581 }
86582
86583
86584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
86585   float jresult ;
86586   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86587   float arg2 ;
86588   float result;
86589
86590   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86591   arg2 = (float)jarg2;
86592   {
86593     try {
86594       result = (float)(arg1)->GetWidthForHeight(arg2);
86595     } catch (std::out_of_range& e) {
86596       {
86597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86598       };
86599     } catch (std::exception& e) {
86600       {
86601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86602       };
86603     } catch (Dali::DaliException e) {
86604       {
86605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86606       };
86607     } catch (...) {
86608       {
86609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86610       };
86611     }
86612   }
86613
86614   jresult = result;
86615   return jresult;
86616 }
86617
86618
86619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
86620   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86621   Dali::Vector2 *arg2 = 0 ;
86622
86623   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86624   arg2 = (Dali::Vector2 *)jarg2;
86625   if (!arg2) {
86626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
86627     return ;
86628   }
86629   {
86630     try {
86631       (arg1)->GetNaturalSize(*arg2);
86632     } catch (std::out_of_range& e) {
86633       {
86634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86635       };
86636     } catch (std::exception& e) {
86637       {
86638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86639       };
86640     } catch (Dali::DaliException e) {
86641       {
86642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86643       };
86644     } catch (...) {
86645       {
86646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86647       };
86648     }
86649   }
86650
86651 }
86652
86653
86654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
86655   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86656   float arg2 ;
86657
86658   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86659   arg2 = (int)jarg2;
86660   {
86661     try {
86662       (arg1)->SetDepthIndex(arg2);
86663     } catch (std::out_of_range& e) {
86664       {
86665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86666       };
86667     } catch (std::exception& e) {
86668       {
86669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86670       };
86671     } catch (Dali::DaliException e) {
86672       {
86673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86674       };
86675     } catch (...) {
86676       {
86677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86678       };
86679     }
86680   }
86681
86682 }
86683
86684
86685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
86686   int jresult ;
86687   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86688   int result;
86689
86690   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86691   {
86692     try {
86693       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
86694     } catch (std::out_of_range& e) {
86695       {
86696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86697       };
86698     } catch (std::exception& e) {
86699       {
86700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86701       };
86702     } catch (Dali::DaliException e) {
86703       {
86704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86705       };
86706     } catch (...) {
86707       {
86708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86709       };
86710     }
86711   }
86712
86713   jresult = result;
86714   return jresult;
86715 }
86716
86717
86718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
86719   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86720   Dali::Property::Map *arg2 = 0 ;
86721
86722   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86723   arg2 = (Dali::Property::Map *)jarg2;
86724   if (!arg2) {
86725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
86726     return ;
86727   }
86728   {
86729     try {
86730       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
86731     } catch (std::out_of_range& e) {
86732       {
86733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86734       };
86735     } catch (std::exception& e) {
86736       {
86737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86738       };
86739     } catch (Dali::DaliException e) {
86740       {
86741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86742       };
86743     } catch (...) {
86744       {
86745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86746       };
86747     }
86748   }
86749
86750 }
86751
86752
86753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
86754   void * jresult ;
86755   Dali::Toolkit::VisualFactory result;
86756
86757   {
86758     try {
86759       result = Dali::Toolkit::VisualFactory::Get();
86760     } catch (std::out_of_range& e) {
86761       {
86762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86763       };
86764     } catch (std::exception& e) {
86765       {
86766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86767       };
86768     } catch (Dali::DaliException e) {
86769       {
86770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86771       };
86772     } catch (...) {
86773       {
86774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86775       };
86776     }
86777   }
86778
86779   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
86780   return jresult;
86781 }
86782
86783
86784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
86785   void * jresult ;
86786   Dali::Toolkit::VisualFactory *result = 0 ;
86787
86788   {
86789     try {
86790       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
86791     } catch (std::out_of_range& e) {
86792       {
86793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86794       };
86795     } catch (std::exception& e) {
86796       {
86797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86798       };
86799     } catch (Dali::DaliException e) {
86800       {
86801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86802       };
86803     } catch (...) {
86804       {
86805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86806       };
86807     }
86808   }
86809
86810   jresult = (void *)result;
86811   return jresult;
86812 }
86813
86814
86815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86816   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86817
86818   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86819   {
86820     try {
86821       delete arg1;
86822     } catch (std::out_of_range& e) {
86823       {
86824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86825       };
86826     } catch (std::exception& e) {
86827       {
86828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86829       };
86830     } catch (Dali::DaliException e) {
86831       {
86832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86833       };
86834     } catch (...) {
86835       {
86836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86837       };
86838     }
86839   }
86840
86841 }
86842
86843
86844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86845   void * jresult ;
86846   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86847   Dali::Toolkit::VisualFactory *result = 0 ;
86848
86849   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86850   if (!arg1) {
86851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86852     return 0;
86853   }
86854   {
86855     try {
86856       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86857     } catch (std::out_of_range& e) {
86858       {
86859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86860       };
86861     } catch (std::exception& e) {
86862       {
86863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86864       };
86865     } catch (Dali::DaliException e) {
86866       {
86867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86868       };
86869     } catch (...) {
86870       {
86871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86872       };
86873     }
86874   }
86875
86876   jresult = (void *)result;
86877   return jresult;
86878 }
86879
86880
86881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86882   void * jresult ;
86883   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86884   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86885   Dali::Toolkit::VisualFactory *result = 0 ;
86886
86887   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86888   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86889   if (!arg2) {
86890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86891     return 0;
86892   }
86893   {
86894     try {
86895       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86896     } catch (std::out_of_range& e) {
86897       {
86898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86899       };
86900     } catch (std::exception& e) {
86901       {
86902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86903       };
86904     } catch (Dali::DaliException e) {
86905       {
86906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86907       };
86908     } catch (...) {
86909       {
86910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86911       };
86912     }
86913   }
86914
86915   jresult = (void *)result;
86916   return jresult;
86917 }
86918
86919
86920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86921   void * jresult ;
86922   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86923   Dali::Property::Map *arg2 = 0 ;
86924   Dali::Toolkit::Visual::Base result;
86925
86926   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86927   arg2 = (Dali::Property::Map *)jarg2;
86928   if (!arg2) {
86929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86930     return 0;
86931   }
86932   {
86933     try {
86934       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86935     } catch (std::out_of_range& e) {
86936       {
86937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86938       };
86939     } catch (std::exception& e) {
86940       {
86941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86942       };
86943     } catch (Dali::DaliException e) {
86944       {
86945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86946       };
86947     } catch (...) {
86948       {
86949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86950       };
86951     }
86952   }
86953
86954   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86955   return jresult;
86956 }
86957
86958
86959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86960   void * jresult ;
86961   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86962   std::string *arg2 = 0 ;
86963   Dali::ImageDimensions arg3 ;
86964   Dali::ImageDimensions *argp3 ;
86965   Dali::Toolkit::Visual::Base result;
86966
86967   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86968   if (!jarg2) {
86969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86970     return 0;
86971   }
86972   std::string arg2_str(jarg2);
86973   arg2 = &arg2_str;
86974   argp3 = (Dali::ImageDimensions *)jarg3;
86975   if (!argp3) {
86976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86977     return 0;
86978   }
86979   arg3 = *argp3;
86980   {
86981     try {
86982       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86983     } catch (std::out_of_range& e) {
86984       {
86985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86986       };
86987     } catch (std::exception& e) {
86988       {
86989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86990       };
86991     } catch (Dali::DaliException e) {
86992       {
86993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86994       };
86995     } catch (...) {
86996       {
86997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86998       };
86999     }
87000   }
87001
87002   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
87003
87004   //argout typemap for const std::string&
87005
87006   return jresult;
87007 }
87008
87009
87010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
87011   void * jresult ;
87012   Dali::Toolkit::AsyncImageLoader *result = 0 ;
87013
87014   {
87015     try {
87016       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
87017     } catch (std::out_of_range& e) {
87018       {
87019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87020       };
87021     } catch (std::exception& e) {
87022       {
87023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87024       };
87025     } catch (Dali::DaliException e) {
87026       {
87027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87028       };
87029     } catch (...) {
87030       {
87031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87032       };
87033     }
87034   }
87035
87036   jresult = (void *)result;
87037   return jresult;
87038 }
87039
87040
87041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
87042   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87043
87044   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87045   {
87046     try {
87047       delete arg1;
87048     } catch (std::out_of_range& e) {
87049       {
87050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87051       };
87052     } catch (std::exception& e) {
87053       {
87054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87055       };
87056     } catch (Dali::DaliException e) {
87057       {
87058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87059       };
87060     } catch (...) {
87061       {
87062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87063       };
87064     }
87065   }
87066
87067 }
87068
87069
87070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
87071   void * jresult ;
87072   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
87073   Dali::Toolkit::AsyncImageLoader *result = 0 ;
87074
87075   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87076   if (!arg1) {
87077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
87078     return 0;
87079   }
87080   {
87081     try {
87082       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
87083     } catch (std::out_of_range& e) {
87084       {
87085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87086       };
87087     } catch (std::exception& e) {
87088       {
87089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87090       };
87091     } catch (Dali::DaliException e) {
87092       {
87093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87094       };
87095     } catch (...) {
87096       {
87097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87098       };
87099     }
87100   }
87101
87102   jresult = (void *)result;
87103   return jresult;
87104 }
87105
87106
87107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
87108   void * jresult ;
87109   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87110   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
87111   Dali::Toolkit::AsyncImageLoader *result = 0 ;
87112
87113   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87114   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
87115   if (!arg2) {
87116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
87117     return 0;
87118   }
87119   {
87120     try {
87121       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
87122     } catch (std::out_of_range& e) {
87123       {
87124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87125       };
87126     } catch (std::exception& e) {
87127       {
87128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87129       };
87130     } catch (Dali::DaliException e) {
87131       {
87132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87133       };
87134     } catch (...) {
87135       {
87136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87137       };
87138     }
87139   }
87140
87141   jresult = (void *)result;
87142   return jresult;
87143 }
87144
87145
87146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
87147   void * jresult ;
87148   Dali::Toolkit::AsyncImageLoader result;
87149
87150   {
87151     try {
87152       result = Dali::Toolkit::AsyncImageLoader::New();
87153     } catch (std::out_of_range& e) {
87154       {
87155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87156       };
87157     } catch (std::exception& e) {
87158       {
87159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87160       };
87161     } catch (Dali::DaliException e) {
87162       {
87163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87164       };
87165     } catch (...) {
87166       {
87167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87168       };
87169     }
87170   }
87171
87172   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
87173   return jresult;
87174 }
87175
87176
87177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
87178   void * jresult ;
87179   Dali::BaseHandle arg1 ;
87180   Dali::BaseHandle *argp1 ;
87181   Dali::Toolkit::AsyncImageLoader result;
87182
87183   argp1 = (Dali::BaseHandle *)jarg1;
87184   if (!argp1) {
87185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87186     return 0;
87187   }
87188   arg1 = *argp1;
87189   {
87190     try {
87191       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
87192     } catch (std::out_of_range& e) {
87193       {
87194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87195       };
87196     } catch (std::exception& e) {
87197       {
87198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87199       };
87200     } catch (Dali::DaliException e) {
87201       {
87202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87203       };
87204     } catch (...) {
87205       {
87206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87207       };
87208     }
87209   }
87210
87211   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
87212   return jresult;
87213 }
87214
87215
87216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
87217   unsigned int jresult ;
87218   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87219   std::string *arg2 = 0 ;
87220   uint32_t result;
87221
87222   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87223   if (!jarg2) {
87224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87225     return 0;
87226   }
87227   std::string arg2_str(jarg2);
87228   arg2 = &arg2_str;
87229   {
87230     try {
87231       result = (arg1)->Load((std::string const &)*arg2);
87232     } catch (std::out_of_range& e) {
87233       {
87234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87235       };
87236     } catch (std::exception& e) {
87237       {
87238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87239       };
87240     } catch (Dali::DaliException e) {
87241       {
87242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87243       };
87244     } catch (...) {
87245       {
87246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87247       };
87248     }
87249   }
87250
87251   jresult = result;
87252
87253   //argout typemap for const std::string&
87254
87255   return jresult;
87256 }
87257
87258
87259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
87260   unsigned int jresult ;
87261   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87262   std::string *arg2 = 0 ;
87263   Dali::ImageDimensions arg3 ;
87264   Dali::ImageDimensions *argp3 ;
87265   uint32_t result;
87266
87267   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87268   if (!jarg2) {
87269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87270     return 0;
87271   }
87272   std::string arg2_str(jarg2);
87273   arg2 = &arg2_str;
87274   argp3 = (Dali::ImageDimensions *)jarg3;
87275   if (!argp3) {
87276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87277     return 0;
87278   }
87279   arg3 = *argp3;
87280   {
87281     try {
87282       result = (arg1)->Load((std::string const &)*arg2,arg3);
87283     } catch (std::out_of_range& e) {
87284       {
87285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87286       };
87287     } catch (std::exception& e) {
87288       {
87289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87290       };
87291     } catch (Dali::DaliException e) {
87292       {
87293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87294       };
87295     } catch (...) {
87296       {
87297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87298       };
87299     }
87300   }
87301
87302   jresult = result;
87303
87304   //argout typemap for const std::string&
87305
87306   return jresult;
87307 }
87308
87309
87310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
87311   unsigned int jresult ;
87312   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87313   std::string *arg2 = 0 ;
87314   Dali::ImageDimensions arg3 ;
87315   Dali::FittingMode::Type arg4 ;
87316   Dali::SamplingMode::Type arg5 ;
87317   bool arg6 ;
87318   Dali::ImageDimensions *argp3 ;
87319   uint32_t result;
87320
87321   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87322   if (!jarg2) {
87323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87324     return 0;
87325   }
87326   std::string arg2_str(jarg2);
87327   arg2 = &arg2_str;
87328   argp3 = (Dali::ImageDimensions *)jarg3;
87329   if (!argp3) {
87330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87331     return 0;
87332   }
87333   arg3 = *argp3;
87334   arg4 = (Dali::FittingMode::Type)jarg4;
87335   arg5 = (Dali::SamplingMode::Type)jarg5;
87336   arg6 = jarg6 ? true : false;
87337   {
87338     try {
87339       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
87340     } catch (std::out_of_range& e) {
87341       {
87342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87343       };
87344     } catch (std::exception& e) {
87345       {
87346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87347       };
87348     } catch (Dali::DaliException e) {
87349       {
87350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87351       };
87352     } catch (...) {
87353       {
87354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87355       };
87356     }
87357   }
87358
87359   jresult = result;
87360
87361   //argout typemap for const std::string&
87362
87363   return jresult;
87364 }
87365
87366
87367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
87368   unsigned int jresult ;
87369   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87370   uint32_t arg2 ;
87371   bool result;
87372
87373   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87374   arg2 = (uint32_t)jarg2;
87375   {
87376     try {
87377       result = (bool)(arg1)->Cancel(arg2);
87378     } catch (std::out_of_range& e) {
87379       {
87380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87381       };
87382     } catch (std::exception& e) {
87383       {
87384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87385       };
87386     } catch (Dali::DaliException e) {
87387       {
87388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87389       };
87390     } catch (...) {
87391       {
87392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87393       };
87394     }
87395   }
87396
87397   jresult = result;
87398   return jresult;
87399 }
87400
87401
87402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
87403   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87404
87405   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87406   {
87407     try {
87408       (arg1)->CancelAll();
87409     } catch (std::out_of_range& e) {
87410       {
87411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87412       };
87413     } catch (std::exception& e) {
87414       {
87415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87416       };
87417     } catch (Dali::DaliException e) {
87418       {
87419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87420       };
87421     } catch (...) {
87422       {
87423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87424       };
87425     }
87426   }
87427
87428 }
87429
87430
87431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
87432   void * jresult ;
87433   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87434   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
87435
87436   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87437   {
87438     try {
87439       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
87440     } catch (std::out_of_range& e) {
87441       {
87442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87443       };
87444     } catch (std::exception& e) {
87445       {
87446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87447       };
87448     } catch (Dali::DaliException e) {
87449       {
87450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87451       };
87452     } catch (...) {
87453       {
87454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87455       };
87456     }
87457   }
87458
87459   jresult = (void *)result;
87460   return jresult;
87461 }
87462
87463
87464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
87465   void * jresult ;
87466   std::string *arg1 = 0 ;
87467   Dali::PixelData result;
87468
87469   if (!jarg1) {
87470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87471     return 0;
87472   }
87473   std::string arg1_str(jarg1);
87474   arg1 = &arg1_str;
87475   {
87476     try {
87477       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
87478     } catch (std::out_of_range& e) {
87479       {
87480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87481       };
87482     } catch (std::exception& e) {
87483       {
87484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87485       };
87486     } catch (Dali::DaliException e) {
87487       {
87488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87489       };
87490     } catch (...) {
87491       {
87492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87493       };
87494     }
87495   }
87496
87497   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87498
87499   //argout typemap for const std::string&
87500
87501   return jresult;
87502 }
87503
87504
87505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
87506   void * jresult ;
87507   std::string *arg1 = 0 ;
87508   Dali::ImageDimensions arg2 ;
87509   Dali::ImageDimensions *argp2 ;
87510   Dali::PixelData result;
87511
87512   if (!jarg1) {
87513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87514     return 0;
87515   }
87516   std::string arg1_str(jarg1);
87517   arg1 = &arg1_str;
87518   argp2 = (Dali::ImageDimensions *)jarg2;
87519   if (!argp2) {
87520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87521     return 0;
87522   }
87523   arg2 = *argp2;
87524   {
87525     try {
87526       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
87527     } catch (std::out_of_range& e) {
87528       {
87529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87530       };
87531     } catch (std::exception& e) {
87532       {
87533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87534       };
87535     } catch (Dali::DaliException e) {
87536       {
87537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87538       };
87539     } catch (...) {
87540       {
87541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87542       };
87543     }
87544   }
87545
87546   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87547
87548   //argout typemap for const std::string&
87549
87550   return jresult;
87551 }
87552
87553
87554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
87555   void * jresult ;
87556   std::string *arg1 = 0 ;
87557   Dali::ImageDimensions arg2 ;
87558   Dali::FittingMode::Type arg3 ;
87559   Dali::SamplingMode::Type arg4 ;
87560   bool arg5 ;
87561   Dali::ImageDimensions *argp2 ;
87562   Dali::PixelData result;
87563
87564   if (!jarg1) {
87565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87566     return 0;
87567   }
87568   std::string arg1_str(jarg1);
87569   arg1 = &arg1_str;
87570   argp2 = (Dali::ImageDimensions *)jarg2;
87571   if (!argp2) {
87572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87573     return 0;
87574   }
87575   arg2 = *argp2;
87576   arg3 = (Dali::FittingMode::Type)jarg3;
87577   arg4 = (Dali::SamplingMode::Type)jarg4;
87578   arg5 = jarg5 ? true : false;
87579   {
87580     try {
87581       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
87582     } catch (std::out_of_range& e) {
87583       {
87584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87585       };
87586     } catch (std::exception& e) {
87587       {
87588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87589       };
87590     } catch (Dali::DaliException e) {
87591       {
87592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87593       };
87594     } catch (...) {
87595       {
87596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87597       };
87598     }
87599   }
87600
87601   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87602
87603   //argout typemap for const std::string&
87604
87605   return jresult;
87606 }
87607
87608
87609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
87610   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87611
87612   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87613   {
87614     try {
87615       delete arg1;
87616     } catch (std::out_of_range& e) {
87617       {
87618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87619       };
87620     } catch (std::exception& e) {
87621       {
87622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87623       };
87624     } catch (Dali::DaliException e) {
87625       {
87626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87627       };
87628     } catch (...) {
87629       {
87630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87631       };
87632     }
87633   }
87634
87635 }
87636
87637
87638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
87639   void * jresult ;
87640   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87641   Dali::Actor arg2 ;
87642   Dali::Actor arg3 ;
87643   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
87644   Dali::Actor *argp2 ;
87645   Dali::Actor *argp3 ;
87646   Dali::Actor result;
87647
87648   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87649   argp2 = (Dali::Actor *)jarg2;
87650   if (!argp2) {
87651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87652     return 0;
87653   }
87654   arg2 = *argp2;
87655   argp3 = (Dali::Actor *)jarg3;
87656   if (!argp3) {
87657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87658     return 0;
87659   }
87660   arg3 = *argp3;
87661   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
87662   {
87663     try {
87664       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
87665     } catch (std::out_of_range& e) {
87666       {
87667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87668       };
87669     } catch (std::exception& e) {
87670       {
87671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87672       };
87673     } catch (Dali::DaliException e) {
87674       {
87675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87676       };
87677     } catch (...) {
87678       {
87679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87680       };
87681     }
87682   }
87683
87684   jresult = new Dali::Actor((const Dali::Actor &)result);
87685   return jresult;
87686 }
87687
87688
87689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
87690   void * jresult ;
87691   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
87692
87693   {
87694     try {
87695       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
87696     } catch (std::out_of_range& e) {
87697       {
87698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87699       };
87700     } catch (std::exception& e) {
87701       {
87702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87703       };
87704     } catch (Dali::DaliException e) {
87705       {
87706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87707       };
87708     } catch (...) {
87709       {
87710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87711       };
87712     }
87713   }
87714
87715   jresult = (void *)result;
87716   return jresult;
87717 }
87718
87719
87720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87721   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87722   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87723   if (director) {
87724     director->swig_connect_director(callback0);
87725   }
87726 }
87727
87728
87729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87730   KeyboardFocusManager arg1 ;
87731   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87732   KeyboardFocusManager *argp1 ;
87733
87734   argp1 = (KeyboardFocusManager *)jarg1;
87735   if (!argp1) {
87736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87737     return ;
87738   }
87739   arg1 = *argp1;
87740   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87741   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87742   {
87743     try {
87744       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87745     } catch (std::out_of_range& e) {
87746       {
87747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87748       };
87749     } catch (std::exception& e) {
87750       {
87751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87752       };
87753     } catch (Dali::DaliException e) {
87754       {
87755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87756       };
87757     } catch (...) {
87758       {
87759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87760       };
87761     }
87762   }
87763
87764 }
87765
87766
87767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87768   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87769
87770   arg1 = (std::vector< unsigned int > *)jarg1;
87771   {
87772     try {
87773       (arg1)->clear();
87774     } catch (std::out_of_range& e) {
87775       {
87776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87777       };
87778     } catch (std::exception& e) {
87779       {
87780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87781       };
87782     } catch (Dali::DaliException e) {
87783       {
87784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87785       };
87786     } catch (...) {
87787       {
87788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87789       };
87790     }
87791   }
87792
87793 }
87794
87795
87796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87797   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87798   unsigned int *arg2 = 0 ;
87799   unsigned int temp2 ;
87800
87801   arg1 = (std::vector< unsigned int > *)jarg1;
87802   temp2 = (unsigned int)jarg2;
87803   arg2 = &temp2;
87804   {
87805     try {
87806       (arg1)->push_back((unsigned int const &)*arg2);
87807     } catch (std::out_of_range& e) {
87808       {
87809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87810       };
87811     } catch (std::exception& e) {
87812       {
87813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87814       };
87815     } catch (Dali::DaliException e) {
87816       {
87817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87818       };
87819     } catch (...) {
87820       {
87821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87822       };
87823     }
87824   }
87825
87826 }
87827
87828
87829 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87830   unsigned long jresult ;
87831   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87832   std::vector< unsigned int >::size_type result;
87833
87834   arg1 = (std::vector< unsigned int > *)jarg1;
87835   {
87836     try {
87837       result = ((std::vector< unsigned int > const *)arg1)->size();
87838     } catch (std::out_of_range& e) {
87839       {
87840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87841       };
87842     } catch (std::exception& e) {
87843       {
87844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87845       };
87846     } catch (Dali::DaliException e) {
87847       {
87848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87849       };
87850     } catch (...) {
87851       {
87852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87853       };
87854     }
87855   }
87856
87857   jresult = (unsigned long)result;
87858   return jresult;
87859 }
87860
87861
87862 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87863   unsigned long jresult ;
87864   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87865   std::vector< unsigned int >::size_type result;
87866
87867   arg1 = (std::vector< unsigned int > *)jarg1;
87868   {
87869     try {
87870       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87871     } catch (std::out_of_range& e) {
87872       {
87873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87874       };
87875     } catch (std::exception& e) {
87876       {
87877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87878       };
87879     } catch (Dali::DaliException e) {
87880       {
87881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87882       };
87883     } catch (...) {
87884       {
87885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87886       };
87887     }
87888   }
87889
87890   jresult = (unsigned long)result;
87891   return jresult;
87892 }
87893
87894
87895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87896   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87897   std::vector< unsigned int >::size_type arg2 ;
87898
87899   arg1 = (std::vector< unsigned int > *)jarg1;
87900   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87901   {
87902     try {
87903       (arg1)->reserve(arg2);
87904     } catch (std::out_of_range& e) {
87905       {
87906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87907       };
87908     } catch (std::exception& e) {
87909       {
87910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87911       };
87912     } catch (Dali::DaliException e) {
87913       {
87914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87915       };
87916     } catch (...) {
87917       {
87918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87919       };
87920     }
87921   }
87922
87923 }
87924
87925
87926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87927   void * jresult ;
87928   std::vector< unsigned int > *result = 0 ;
87929
87930   {
87931     try {
87932       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87933     } catch (std::out_of_range& e) {
87934       {
87935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87936       };
87937     } catch (std::exception& e) {
87938       {
87939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87940       };
87941     } catch (Dali::DaliException e) {
87942       {
87943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87944       };
87945     } catch (...) {
87946       {
87947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87948       };
87949     }
87950   }
87951
87952   jresult = (void *)result;
87953   return jresult;
87954 }
87955
87956
87957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87958   void * jresult ;
87959   std::vector< unsigned int > *arg1 = 0 ;
87960   std::vector< unsigned int > *result = 0 ;
87961
87962   arg1 = (std::vector< unsigned int > *)jarg1;
87963   if (!arg1) {
87964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87965     return 0;
87966   }
87967   {
87968     try {
87969       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87970     } catch (std::out_of_range& e) {
87971       {
87972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87973       };
87974     } catch (std::exception& e) {
87975       {
87976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87977       };
87978     } catch (Dali::DaliException e) {
87979       {
87980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87981       };
87982     } catch (...) {
87983       {
87984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87985       };
87986     }
87987   }
87988
87989   jresult = (void *)result;
87990   return jresult;
87991 }
87992
87993
87994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87995   void * jresult ;
87996   int arg1 ;
87997   std::vector< unsigned int > *result = 0 ;
87998
87999   arg1 = (int)jarg1;
88000   {
88001     try {
88002       try {
88003         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
88004       }
88005       catch(std::out_of_range &_e) {
88006         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88007         return 0;
88008       }
88009
88010     } catch (std::out_of_range& e) {
88011       {
88012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88013       };
88014     } catch (std::exception& e) {
88015       {
88016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88017       };
88018     } catch (Dali::DaliException e) {
88019       {
88020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88021       };
88022     } catch (...) {
88023       {
88024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88025       };
88026     }
88027   }
88028
88029   jresult = (void *)result;
88030   return jresult;
88031 }
88032
88033
88034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
88035   unsigned int jresult ;
88036   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88037   int arg2 ;
88038   unsigned int result;
88039
88040   arg1 = (std::vector< unsigned int > *)jarg1;
88041   arg2 = (int)jarg2;
88042   {
88043     try {
88044       try {
88045         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
88046       }
88047       catch(std::out_of_range &_e) {
88048         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88049         return 0;
88050       }
88051
88052     } catch (std::out_of_range& e) {
88053       {
88054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88055       };
88056     } catch (std::exception& e) {
88057       {
88058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88059       };
88060     } catch (Dali::DaliException e) {
88061       {
88062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88063       };
88064     } catch (...) {
88065       {
88066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88067       };
88068     }
88069   }
88070
88071   jresult = result;
88072   return jresult;
88073 }
88074
88075
88076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
88077   unsigned int jresult ;
88078   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88079   int arg2 ;
88080   unsigned int *result = 0 ;
88081
88082   arg1 = (std::vector< unsigned int > *)jarg1;
88083   arg2 = (int)jarg2;
88084   {
88085     try {
88086       try {
88087         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
88088       }
88089       catch(std::out_of_range &_e) {
88090         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88091         return 0;
88092       }
88093
88094     } catch (std::out_of_range& e) {
88095       {
88096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88097       };
88098     } catch (std::exception& e) {
88099       {
88100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88101       };
88102     } catch (Dali::DaliException e) {
88103       {
88104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88105       };
88106     } catch (...) {
88107       {
88108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88109       };
88110     }
88111   }
88112
88113   jresult = *result;
88114   return jresult;
88115 }
88116
88117
88118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
88119   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88120   int arg2 ;
88121   unsigned int *arg3 = 0 ;
88122   unsigned int temp3 ;
88123
88124   arg1 = (std::vector< unsigned int > *)jarg1;
88125   arg2 = (int)jarg2;
88126   temp3 = (unsigned int)jarg3;
88127   arg3 = &temp3;
88128   {
88129     try {
88130       try {
88131         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
88132       }
88133       catch(std::out_of_range &_e) {
88134         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88135         return ;
88136       }
88137
88138     } catch (std::out_of_range& e) {
88139       {
88140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88141       };
88142     } catch (std::exception& e) {
88143       {
88144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88145       };
88146     } catch (Dali::DaliException e) {
88147       {
88148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88149       };
88150     } catch (...) {
88151       {
88152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88153       };
88154     }
88155   }
88156
88157 }
88158
88159
88160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
88161   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88162   std::vector< unsigned int > *arg2 = 0 ;
88163
88164   arg1 = (std::vector< unsigned int > *)jarg1;
88165   arg2 = (std::vector< unsigned int > *)jarg2;
88166   if (!arg2) {
88167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88168     return ;
88169   }
88170   {
88171     try {
88172       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
88173     } catch (std::out_of_range& e) {
88174       {
88175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88176       };
88177     } catch (std::exception& e) {
88178       {
88179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88180       };
88181     } catch (Dali::DaliException e) {
88182       {
88183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88184       };
88185     } catch (...) {
88186       {
88187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88188       };
88189     }
88190   }
88191
88192 }
88193
88194
88195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88196   void * jresult ;
88197   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88198   int arg2 ;
88199   int arg3 ;
88200   std::vector< unsigned int > *result = 0 ;
88201
88202   arg1 = (std::vector< unsigned int > *)jarg1;
88203   arg2 = (int)jarg2;
88204   arg3 = (int)jarg3;
88205   {
88206     try {
88207       try {
88208         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
88209       }
88210       catch(std::out_of_range &_e) {
88211         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88212         return 0;
88213       }
88214       catch(std::invalid_argument &_e) {
88215         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88216         return 0;
88217       }
88218
88219     } catch (std::out_of_range& e) {
88220       {
88221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88222       };
88223     } catch (std::exception& e) {
88224       {
88225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88226       };
88227     } catch (Dali::DaliException e) {
88228       {
88229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88230       };
88231     } catch (...) {
88232       {
88233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88234       };
88235     }
88236   }
88237
88238   jresult = (void *)result;
88239   return jresult;
88240 }
88241
88242
88243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
88244   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88245   int arg2 ;
88246   unsigned int *arg3 = 0 ;
88247   unsigned int temp3 ;
88248
88249   arg1 = (std::vector< unsigned int > *)jarg1;
88250   arg2 = (int)jarg2;
88251   temp3 = (unsigned int)jarg3;
88252   arg3 = &temp3;
88253   {
88254     try {
88255       try {
88256         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
88257       }
88258       catch(std::out_of_range &_e) {
88259         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88260         return ;
88261       }
88262
88263     } catch (std::out_of_range& e) {
88264       {
88265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88266       };
88267     } catch (std::exception& e) {
88268       {
88269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88270       };
88271     } catch (Dali::DaliException e) {
88272       {
88273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88274       };
88275     } catch (...) {
88276       {
88277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88278       };
88279     }
88280   }
88281
88282 }
88283
88284
88285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88286   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88287   int arg2 ;
88288   std::vector< unsigned int > *arg3 = 0 ;
88289
88290   arg1 = (std::vector< unsigned int > *)jarg1;
88291   arg2 = (int)jarg2;
88292   arg3 = (std::vector< unsigned int > *)jarg3;
88293   if (!arg3) {
88294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88295     return ;
88296   }
88297   {
88298     try {
88299       try {
88300         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
88301       }
88302       catch(std::out_of_range &_e) {
88303         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88304         return ;
88305       }
88306
88307     } catch (std::out_of_range& e) {
88308       {
88309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88310       };
88311     } catch (std::exception& e) {
88312       {
88313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88314       };
88315     } catch (Dali::DaliException e) {
88316       {
88317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88318       };
88319     } catch (...) {
88320       {
88321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88322       };
88323     }
88324   }
88325
88326 }
88327
88328
88329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
88330   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88331   int arg2 ;
88332
88333   arg1 = (std::vector< unsigned int > *)jarg1;
88334   arg2 = (int)jarg2;
88335   {
88336     try {
88337       try {
88338         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
88339       }
88340       catch(std::out_of_range &_e) {
88341         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88342         return ;
88343       }
88344
88345     } catch (std::out_of_range& e) {
88346       {
88347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88348       };
88349     } catch (std::exception& e) {
88350       {
88351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88352       };
88353     } catch (Dali::DaliException e) {
88354       {
88355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88356       };
88357     } catch (...) {
88358       {
88359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88360       };
88361     }
88362   }
88363
88364 }
88365
88366
88367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88368   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88369   int arg2 ;
88370   int arg3 ;
88371
88372   arg1 = (std::vector< unsigned int > *)jarg1;
88373   arg2 = (int)jarg2;
88374   arg3 = (int)jarg3;
88375   {
88376     try {
88377       try {
88378         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
88379       }
88380       catch(std::out_of_range &_e) {
88381         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88382         return ;
88383       }
88384       catch(std::invalid_argument &_e) {
88385         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88386         return ;
88387       }
88388
88389     } catch (std::out_of_range& e) {
88390       {
88391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88392       };
88393     } catch (std::exception& e) {
88394       {
88395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88396       };
88397     } catch (Dali::DaliException e) {
88398       {
88399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88400       };
88401     } catch (...) {
88402       {
88403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88404       };
88405     }
88406   }
88407
88408 }
88409
88410
88411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
88412   void * jresult ;
88413   unsigned int *arg1 = 0 ;
88414   int arg2 ;
88415   unsigned int temp1 ;
88416   std::vector< unsigned int > *result = 0 ;
88417
88418   temp1 = (unsigned int)jarg1;
88419   arg1 = &temp1;
88420   arg2 = (int)jarg2;
88421   {
88422     try {
88423       try {
88424         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
88425       }
88426       catch(std::out_of_range &_e) {
88427         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88428         return 0;
88429       }
88430
88431     } catch (std::out_of_range& e) {
88432       {
88433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88434       };
88435     } catch (std::exception& e) {
88436       {
88437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88438       };
88439     } catch (Dali::DaliException e) {
88440       {
88441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88442       };
88443     } catch (...) {
88444       {
88445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88446       };
88447     }
88448   }
88449
88450   jresult = (void *)result;
88451   return jresult;
88452 }
88453
88454
88455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
88456   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88457
88458   arg1 = (std::vector< unsigned int > *)jarg1;
88459   {
88460     try {
88461       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
88462     } catch (std::out_of_range& e) {
88463       {
88464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88465       };
88466     } catch (std::exception& e) {
88467       {
88468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88469       };
88470     } catch (Dali::DaliException e) {
88471       {
88472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88473       };
88474     } catch (...) {
88475       {
88476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88477       };
88478     }
88479   }
88480
88481 }
88482
88483
88484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88485   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88486   int arg2 ;
88487   int arg3 ;
88488
88489   arg1 = (std::vector< unsigned int > *)jarg1;
88490   arg2 = (int)jarg2;
88491   arg3 = (int)jarg3;
88492   {
88493     try {
88494       try {
88495         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88496       }
88497       catch(std::out_of_range &_e) {
88498         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88499         return ;
88500       }
88501       catch(std::invalid_argument &_e) {
88502         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88503         return ;
88504       }
88505
88506     } catch (std::out_of_range& e) {
88507       {
88508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88509       };
88510     } catch (std::exception& e) {
88511       {
88512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88513       };
88514     } catch (Dali::DaliException e) {
88515       {
88516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88517       };
88518     } catch (...) {
88519       {
88520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88521       };
88522     }
88523   }
88524
88525 }
88526
88527
88528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88529   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88530   int arg2 ;
88531   std::vector< unsigned int > *arg3 = 0 ;
88532
88533   arg1 = (std::vector< unsigned int > *)jarg1;
88534   arg2 = (int)jarg2;
88535   arg3 = (std::vector< unsigned int > *)jarg3;
88536   if (!arg3) {
88537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88538     return ;
88539   }
88540   {
88541     try {
88542       try {
88543         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
88544       }
88545       catch(std::out_of_range &_e) {
88546         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88547         return ;
88548       }
88549
88550     } catch (std::out_of_range& e) {
88551       {
88552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88553       };
88554     } catch (std::exception& e) {
88555       {
88556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88557       };
88558     } catch (Dali::DaliException e) {
88559       {
88560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88561       };
88562     } catch (...) {
88563       {
88564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88565       };
88566     }
88567   }
88568
88569 }
88570
88571
88572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
88573   unsigned int jresult ;
88574   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88575   unsigned int *arg2 = 0 ;
88576   unsigned int temp2 ;
88577   bool result;
88578
88579   arg1 = (std::vector< unsigned int > *)jarg1;
88580   temp2 = (unsigned int)jarg2;
88581   arg2 = &temp2;
88582   {
88583     try {
88584       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
88585     } catch (std::out_of_range& e) {
88586       {
88587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88588       };
88589     } catch (std::exception& e) {
88590       {
88591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88592       };
88593     } catch (Dali::DaliException e) {
88594       {
88595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88596       };
88597     } catch (...) {
88598       {
88599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88600       };
88601     }
88602   }
88603
88604   jresult = result;
88605   return jresult;
88606 }
88607
88608
88609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
88610   int jresult ;
88611   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88612   unsigned int *arg2 = 0 ;
88613   unsigned int temp2 ;
88614   int result;
88615
88616   arg1 = (std::vector< unsigned int > *)jarg1;
88617   temp2 = (unsigned int)jarg2;
88618   arg2 = &temp2;
88619   {
88620     try {
88621       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
88622     } catch (std::out_of_range& e) {
88623       {
88624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88625       };
88626     } catch (std::exception& e) {
88627       {
88628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88629       };
88630     } catch (Dali::DaliException e) {
88631       {
88632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88633       };
88634     } catch (...) {
88635       {
88636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88637       };
88638     }
88639   }
88640
88641   jresult = result;
88642   return jresult;
88643 }
88644
88645
88646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
88647   int jresult ;
88648   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88649   unsigned int *arg2 = 0 ;
88650   unsigned int temp2 ;
88651   int result;
88652
88653   arg1 = (std::vector< unsigned int > *)jarg1;
88654   temp2 = (unsigned int)jarg2;
88655   arg2 = &temp2;
88656   {
88657     try {
88658       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
88659     } catch (std::out_of_range& e) {
88660       {
88661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88662       };
88663     } catch (std::exception& e) {
88664       {
88665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88666       };
88667     } catch (Dali::DaliException e) {
88668       {
88669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88670       };
88671     } catch (...) {
88672       {
88673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88674       };
88675     }
88676   }
88677
88678   jresult = result;
88679   return jresult;
88680 }
88681
88682
88683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88684   unsigned int jresult ;
88685   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88686   unsigned int *arg2 = 0 ;
88687   unsigned int temp2 ;
88688   bool result;
88689
88690   arg1 = (std::vector< unsigned int > *)jarg1;
88691   temp2 = (unsigned int)jarg2;
88692   arg2 = &temp2;
88693   {
88694     try {
88695       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88696     } catch (std::out_of_range& e) {
88697       {
88698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88699       };
88700     } catch (std::exception& e) {
88701       {
88702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88703       };
88704     } catch (Dali::DaliException e) {
88705       {
88706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88707       };
88708     } catch (...) {
88709       {
88710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88711       };
88712     }
88713   }
88714
88715   jresult = result;
88716   return jresult;
88717 }
88718
88719
88720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88721   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88722
88723   arg1 = (std::vector< unsigned int > *)jarg1;
88724   {
88725     try {
88726       delete arg1;
88727     } catch (std::out_of_range& e) {
88728       {
88729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88730       };
88731     } catch (std::exception& e) {
88732       {
88733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88734       };
88735     } catch (Dali::DaliException e) {
88736       {
88737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88738       };
88739     } catch (...) {
88740       {
88741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88742       };
88743     }
88744   }
88745
88746 }
88747
88748
88749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88750   void * jresult ;
88751   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88752
88753   {
88754     try {
88755       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88756     } catch (std::out_of_range& e) {
88757       {
88758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88759       };
88760     } catch (std::exception& e) {
88761       {
88762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88763       };
88764     } catch (Dali::DaliException e) {
88765       {
88766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88767       };
88768     } catch (...) {
88769       {
88770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88771       };
88772     }
88773   }
88774
88775   jresult = (void *)result;
88776   return jresult;
88777 }
88778
88779
88780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88781   void * jresult ;
88782   unsigned int arg1 ;
88783   Dali::Actor arg2 ;
88784   Dali::Actor *argp2 ;
88785   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88786
88787   arg1 = (unsigned int)jarg1;
88788   argp2 = (Dali::Actor *)jarg2;
88789   if (!argp2) {
88790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88791     return 0;
88792   }
88793   arg2 = *argp2;
88794   {
88795     try {
88796       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88797     } catch (std::out_of_range& e) {
88798       {
88799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88800       };
88801     } catch (std::exception& e) {
88802       {
88803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88804       };
88805     } catch (Dali::DaliException e) {
88806       {
88807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88808       };
88809     } catch (...) {
88810       {
88811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88812       };
88813     }
88814   }
88815
88816   jresult = (void *)result;
88817   return jresult;
88818 }
88819
88820
88821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88822   void * jresult ;
88823   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88824   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88825
88826   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88827   if (!arg1) {
88828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88829     return 0;
88830   }
88831   {
88832     try {
88833       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88834     } catch (std::out_of_range& e) {
88835       {
88836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88837       };
88838     } catch (std::exception& e) {
88839       {
88840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88841       };
88842     } catch (Dali::DaliException e) {
88843       {
88844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88845       };
88846     } catch (...) {
88847       {
88848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88849       };
88850     }
88851   }
88852
88853   jresult = (void *)result;
88854   return jresult;
88855 }
88856
88857
88858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88859   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88860   unsigned int arg2 ;
88861
88862   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88863   arg2 = (unsigned int)jarg2;
88864   if (arg1) (arg1)->first = arg2;
88865 }
88866
88867
88868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88869   unsigned int jresult ;
88870   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88871   unsigned int result;
88872
88873   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88874   result = (unsigned int) ((arg1)->first);
88875   jresult = result;
88876   return jresult;
88877 }
88878
88879
88880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88881   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88882   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88883
88884   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88885   arg2 = (Dali::Actor *)jarg2;
88886   if (arg1) (arg1)->second = *arg2;
88887 }
88888
88889
88890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88891   void * jresult ;
88892   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88893   Dali::Actor *result = 0 ;
88894
88895   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88896   result = (Dali::Actor *)& ((arg1)->second);
88897   jresult = (void *)result;
88898   return jresult;
88899 }
88900
88901
88902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88903   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88904
88905   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88906   {
88907     try {
88908       delete arg1;
88909     } catch (std::out_of_range& e) {
88910       {
88911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88912       };
88913     } catch (std::exception& e) {
88914       {
88915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88916       };
88917     } catch (Dali::DaliException e) {
88918       {
88919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88920       };
88921     } catch (...) {
88922       {
88923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88924       };
88925     }
88926   }
88927
88928 }
88929
88930
88931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88932   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88933
88934   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88935   {
88936     try {
88937       (arg1)->clear();
88938     } catch (std::out_of_range& e) {
88939       {
88940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88941       };
88942     } catch (std::exception& e) {
88943       {
88944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88945       };
88946     } catch (Dali::DaliException e) {
88947       {
88948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88949       };
88950     } catch (...) {
88951       {
88952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88953       };
88954     }
88955   }
88956
88957 }
88958
88959
88960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88961   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88962   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88963
88964   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88965   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88966   if (!arg2) {
88967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88968     return ;
88969   }
88970   {
88971     try {
88972       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88973     } catch (std::out_of_range& e) {
88974       {
88975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88976       };
88977     } catch (std::exception& e) {
88978       {
88979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88980       };
88981     } catch (Dali::DaliException e) {
88982       {
88983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88984       };
88985     } catch (...) {
88986       {
88987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88988       };
88989     }
88990   }
88991
88992 }
88993
88994
88995 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88996   unsigned long jresult ;
88997   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88998   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88999
89000   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89001   {
89002     try {
89003       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
89004     } catch (std::out_of_range& e) {
89005       {
89006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89007       };
89008     } catch (std::exception& e) {
89009       {
89010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89011       };
89012     } catch (Dali::DaliException e) {
89013       {
89014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89015       };
89016     } catch (...) {
89017       {
89018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89019       };
89020     }
89021   }
89022
89023   jresult = (unsigned long)result;
89024   return jresult;
89025 }
89026
89027
89028 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
89029   unsigned long jresult ;
89030   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89031   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
89032
89033   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89034   {
89035     try {
89036       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
89037     } catch (std::out_of_range& e) {
89038       {
89039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89040       };
89041     } catch (std::exception& e) {
89042       {
89043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89044       };
89045     } catch (Dali::DaliException e) {
89046       {
89047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89048       };
89049     } catch (...) {
89050       {
89051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89052       };
89053     }
89054   }
89055
89056   jresult = (unsigned long)result;
89057   return jresult;
89058 }
89059
89060
89061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
89062   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89063   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
89064
89065   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89066   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
89067   {
89068     try {
89069       (arg1)->reserve(arg2);
89070     } catch (std::out_of_range& e) {
89071       {
89072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89073       };
89074     } catch (std::exception& e) {
89075       {
89076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89077       };
89078     } catch (Dali::DaliException e) {
89079       {
89080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89081       };
89082     } catch (...) {
89083       {
89084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89085       };
89086     }
89087   }
89088
89089 }
89090
89091
89092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
89093   void * jresult ;
89094   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89095
89096   {
89097     try {
89098       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
89099     } catch (std::out_of_range& e) {
89100       {
89101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89102       };
89103     } catch (std::exception& e) {
89104       {
89105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89106       };
89107     } catch (Dali::DaliException e) {
89108       {
89109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89110       };
89111     } catch (...) {
89112       {
89113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89114       };
89115     }
89116   }
89117
89118   jresult = (void *)result;
89119   return jresult;
89120 }
89121
89122
89123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
89124   void * jresult ;
89125   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
89126   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89127
89128   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89129   if (!arg1) {
89130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89131     return 0;
89132   }
89133   {
89134     try {
89135       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);
89136     } catch (std::out_of_range& e) {
89137       {
89138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89139       };
89140     } catch (std::exception& e) {
89141       {
89142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89143       };
89144     } catch (Dali::DaliException e) {
89145       {
89146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89147       };
89148     } catch (...) {
89149       {
89150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89151       };
89152     }
89153   }
89154
89155   jresult = (void *)result;
89156   return jresult;
89157 }
89158
89159
89160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
89161   void * jresult ;
89162   int arg1 ;
89163   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89164
89165   arg1 = (int)jarg1;
89166   {
89167     try {
89168       try {
89169         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);
89170       }
89171       catch(std::out_of_range &_e) {
89172         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89173         return 0;
89174       }
89175
89176     } catch (std::out_of_range& e) {
89177       {
89178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89179       };
89180     } catch (std::exception& e) {
89181       {
89182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89183       };
89184     } catch (Dali::DaliException e) {
89185       {
89186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89187       };
89188     } catch (...) {
89189       {
89190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89191       };
89192     }
89193   }
89194
89195   jresult = (void *)result;
89196   return jresult;
89197 }
89198
89199
89200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
89201   void * jresult ;
89202   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89203   int arg2 ;
89204   std::pair< unsigned int,Dali::Actor > result;
89205
89206   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89207   arg2 = (int)jarg2;
89208   {
89209     try {
89210       try {
89211         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
89212       }
89213       catch(std::out_of_range &_e) {
89214         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89215         return 0;
89216       }
89217
89218     } catch (std::out_of_range& e) {
89219       {
89220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89221       };
89222     } catch (std::exception& e) {
89223       {
89224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89225       };
89226     } catch (Dali::DaliException e) {
89227       {
89228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89229       };
89230     } catch (...) {
89231       {
89232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89233       };
89234     }
89235   }
89236
89237   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
89238   return jresult;
89239 }
89240
89241
89242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
89243   void * jresult ;
89244   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89245   int arg2 ;
89246   std::pair< unsigned int,Dali::Actor > *result = 0 ;
89247
89248   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89249   arg2 = (int)jarg2;
89250   {
89251     try {
89252       try {
89253         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
89254       }
89255       catch(std::out_of_range &_e) {
89256         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89257         return 0;
89258       }
89259
89260     } catch (std::out_of_range& e) {
89261       {
89262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89263       };
89264     } catch (std::exception& e) {
89265       {
89266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89267       };
89268     } catch (Dali::DaliException e) {
89269       {
89270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89271       };
89272     } catch (...) {
89273       {
89274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89275       };
89276     }
89277   }
89278
89279   jresult = (void *)result;
89280   return jresult;
89281 }
89282
89283
89284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89285   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89286   int arg2 ;
89287   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
89288
89289   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89290   arg2 = (int)jarg2;
89291   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
89292   if (!arg3) {
89293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89294     return ;
89295   }
89296   {
89297     try {
89298       try {
89299         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);
89300       }
89301       catch(std::out_of_range &_e) {
89302         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89303         return ;
89304       }
89305
89306     } catch (std::out_of_range& e) {
89307       {
89308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89309       };
89310     } catch (std::exception& e) {
89311       {
89312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89313       };
89314     } catch (Dali::DaliException e) {
89315       {
89316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89317       };
89318     } catch (...) {
89319       {
89320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89321       };
89322     }
89323   }
89324
89325 }
89326
89327
89328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
89329   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89330   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
89331
89332   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89333   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
89334   if (!arg2) {
89335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89336     return ;
89337   }
89338   {
89339     try {
89340       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);
89341     } catch (std::out_of_range& e) {
89342       {
89343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89344       };
89345     } catch (std::exception& e) {
89346       {
89347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89348       };
89349     } catch (Dali::DaliException e) {
89350       {
89351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89352       };
89353     } catch (...) {
89354       {
89355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89356       };
89357     }
89358   }
89359
89360 }
89361
89362
89363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89364   void * jresult ;
89365   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89366   int arg2 ;
89367   int arg3 ;
89368   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89369
89370   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89371   arg2 = (int)jarg2;
89372   arg3 = (int)jarg3;
89373   {
89374     try {
89375       try {
89376         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);
89377       }
89378       catch(std::out_of_range &_e) {
89379         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89380         return 0;
89381       }
89382       catch(std::invalid_argument &_e) {
89383         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89384         return 0;
89385       }
89386
89387     } catch (std::out_of_range& e) {
89388       {
89389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89390       };
89391     } catch (std::exception& e) {
89392       {
89393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89394       };
89395     } catch (Dali::DaliException e) {
89396       {
89397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89398       };
89399     } catch (...) {
89400       {
89401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89402       };
89403     }
89404   }
89405
89406   jresult = (void *)result;
89407   return jresult;
89408 }
89409
89410
89411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89412   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89413   int arg2 ;
89414   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
89415
89416   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89417   arg2 = (int)jarg2;
89418   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
89419   if (!arg3) {
89420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89421     return ;
89422   }
89423   {
89424     try {
89425       try {
89426         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);
89427       }
89428       catch(std::out_of_range &_e) {
89429         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89430         return ;
89431       }
89432
89433     } catch (std::out_of_range& e) {
89434       {
89435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89436       };
89437     } catch (std::exception& e) {
89438       {
89439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89440       };
89441     } catch (Dali::DaliException e) {
89442       {
89443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89444       };
89445     } catch (...) {
89446       {
89447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89448       };
89449     }
89450   }
89451
89452 }
89453
89454
89455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89456   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89457   int arg2 ;
89458   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89459
89460   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89461   arg2 = (int)jarg2;
89462   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89463   if (!arg3) {
89464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89465     return ;
89466   }
89467   {
89468     try {
89469       try {
89470         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);
89471       }
89472       catch(std::out_of_range &_e) {
89473         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89474         return ;
89475       }
89476
89477     } catch (std::out_of_range& e) {
89478       {
89479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89480       };
89481     } catch (std::exception& e) {
89482       {
89483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89484       };
89485     } catch (Dali::DaliException e) {
89486       {
89487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89488       };
89489     } catch (...) {
89490       {
89491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89492       };
89493     }
89494   }
89495
89496 }
89497
89498
89499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
89500   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89501   int arg2 ;
89502
89503   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89504   arg2 = (int)jarg2;
89505   {
89506     try {
89507       try {
89508         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
89509       }
89510       catch(std::out_of_range &_e) {
89511         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89512         return ;
89513       }
89514
89515     } catch (std::out_of_range& e) {
89516       {
89517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89518       };
89519     } catch (std::exception& e) {
89520       {
89521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89522       };
89523     } catch (Dali::DaliException e) {
89524       {
89525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89526       };
89527     } catch (...) {
89528       {
89529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89530       };
89531     }
89532   }
89533
89534 }
89535
89536
89537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89538   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89539   int arg2 ;
89540   int arg3 ;
89541
89542   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89543   arg2 = (int)jarg2;
89544   arg3 = (int)jarg3;
89545   {
89546     try {
89547       try {
89548         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
89549       }
89550       catch(std::out_of_range &_e) {
89551         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89552         return ;
89553       }
89554       catch(std::invalid_argument &_e) {
89555         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89556         return ;
89557       }
89558
89559     } catch (std::out_of_range& e) {
89560       {
89561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89562       };
89563     } catch (std::exception& e) {
89564       {
89565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89566       };
89567     } catch (Dali::DaliException e) {
89568       {
89569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89570       };
89571     } catch (...) {
89572       {
89573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89574       };
89575     }
89576   }
89577
89578 }
89579
89580
89581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
89582   void * jresult ;
89583   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
89584   int arg2 ;
89585   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89586
89587   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89588   if (!arg1) {
89589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89590     return 0;
89591   }
89592   arg2 = (int)jarg2;
89593   {
89594     try {
89595       try {
89596         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);
89597       }
89598       catch(std::out_of_range &_e) {
89599         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89600         return 0;
89601       }
89602
89603     } catch (std::out_of_range& e) {
89604       {
89605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89606       };
89607     } catch (std::exception& e) {
89608       {
89609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89610       };
89611     } catch (Dali::DaliException e) {
89612       {
89613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89614       };
89615     } catch (...) {
89616       {
89617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89618       };
89619     }
89620   }
89621
89622   jresult = (void *)result;
89623   return jresult;
89624 }
89625
89626
89627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
89628   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89629
89630   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89631   {
89632     try {
89633       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
89634     } catch (std::out_of_range& e) {
89635       {
89636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89637       };
89638     } catch (std::exception& e) {
89639       {
89640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89641       };
89642     } catch (Dali::DaliException e) {
89643       {
89644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89645       };
89646     } catch (...) {
89647       {
89648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89649       };
89650     }
89651   }
89652
89653 }
89654
89655
89656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89657   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89658   int arg2 ;
89659   int arg3 ;
89660
89661   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89662   arg2 = (int)jarg2;
89663   arg3 = (int)jarg3;
89664   {
89665     try {
89666       try {
89667         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89668       }
89669       catch(std::out_of_range &_e) {
89670         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89671         return ;
89672       }
89673       catch(std::invalid_argument &_e) {
89674         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89675         return ;
89676       }
89677
89678     } catch (std::out_of_range& e) {
89679       {
89680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89681       };
89682     } catch (std::exception& e) {
89683       {
89684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89685       };
89686     } catch (Dali::DaliException e) {
89687       {
89688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89689       };
89690     } catch (...) {
89691       {
89692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89693       };
89694     }
89695   }
89696
89697 }
89698
89699
89700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89701   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89702   int arg2 ;
89703   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89704
89705   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89706   arg2 = (int)jarg2;
89707   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89708   if (!arg3) {
89709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89710     return ;
89711   }
89712   {
89713     try {
89714       try {
89715         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);
89716       }
89717       catch(std::out_of_range &_e) {
89718         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89719         return ;
89720       }
89721
89722     } catch (std::out_of_range& e) {
89723       {
89724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89725       };
89726     } catch (std::exception& e) {
89727       {
89728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89729       };
89730     } catch (Dali::DaliException e) {
89731       {
89732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89733       };
89734     } catch (...) {
89735       {
89736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89737       };
89738     }
89739   }
89740
89741 }
89742
89743
89744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89745   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89746
89747   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89748   {
89749     try {
89750       delete arg1;
89751     } catch (std::out_of_range& e) {
89752       {
89753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89754       };
89755     } catch (std::exception& e) {
89756       {
89757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89758       };
89759     } catch (Dali::DaliException e) {
89760       {
89761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89762       };
89763     } catch (...) {
89764       {
89765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89766       };
89767     }
89768   }
89769
89770 }
89771
89772
89773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89774   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89775
89776   arg1 = (std::vector< Dali::Actor > *)jarg1;
89777   {
89778     try {
89779       (arg1)->clear();
89780     } catch (std::out_of_range& e) {
89781       {
89782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89783       };
89784     } catch (std::exception& e) {
89785       {
89786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89787       };
89788     } catch (Dali::DaliException e) {
89789       {
89790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89791       };
89792     } catch (...) {
89793       {
89794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89795       };
89796     }
89797   }
89798
89799 }
89800
89801
89802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89803   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89804   Dali::Actor *arg2 = 0 ;
89805
89806   arg1 = (std::vector< Dali::Actor > *)jarg1;
89807   arg2 = (Dali::Actor *)jarg2;
89808   if (!arg2) {
89809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89810     return ;
89811   }
89812   {
89813     try {
89814       (arg1)->push_back((Dali::Actor const &)*arg2);
89815     } catch (std::out_of_range& e) {
89816       {
89817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89818       };
89819     } catch (std::exception& e) {
89820       {
89821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89822       };
89823     } catch (Dali::DaliException e) {
89824       {
89825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89826       };
89827     } catch (...) {
89828       {
89829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89830       };
89831     }
89832   }
89833
89834 }
89835
89836
89837 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89838   unsigned long jresult ;
89839   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89840   std::vector< Dali::Actor >::size_type result;
89841
89842   arg1 = (std::vector< Dali::Actor > *)jarg1;
89843   {
89844     try {
89845       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89846     } catch (std::out_of_range& e) {
89847       {
89848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89849       };
89850     } catch (std::exception& e) {
89851       {
89852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89853       };
89854     } catch (Dali::DaliException e) {
89855       {
89856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89857       };
89858     } catch (...) {
89859       {
89860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89861       };
89862     }
89863   }
89864
89865   jresult = (unsigned long)result;
89866   return jresult;
89867 }
89868
89869
89870 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89871   unsigned long jresult ;
89872   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89873   std::vector< Dali::Actor >::size_type result;
89874
89875   arg1 = (std::vector< Dali::Actor > *)jarg1;
89876   {
89877     try {
89878       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89879     } catch (std::out_of_range& e) {
89880       {
89881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89882       };
89883     } catch (std::exception& e) {
89884       {
89885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89886       };
89887     } catch (Dali::DaliException e) {
89888       {
89889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89890       };
89891     } catch (...) {
89892       {
89893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89894       };
89895     }
89896   }
89897
89898   jresult = (unsigned long)result;
89899   return jresult;
89900 }
89901
89902
89903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89904   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89905   std::vector< Dali::Actor >::size_type arg2 ;
89906
89907   arg1 = (std::vector< Dali::Actor > *)jarg1;
89908   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89909   {
89910     try {
89911       (arg1)->reserve(arg2);
89912     } catch (std::out_of_range& e) {
89913       {
89914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89915       };
89916     } catch (std::exception& e) {
89917       {
89918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89919       };
89920     } catch (Dali::DaliException e) {
89921       {
89922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89923       };
89924     } catch (...) {
89925       {
89926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89927       };
89928     }
89929   }
89930
89931 }
89932
89933
89934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89935   void * jresult ;
89936   std::vector< Dali::Actor > *result = 0 ;
89937
89938   {
89939     try {
89940       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89941     } catch (std::out_of_range& e) {
89942       {
89943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89944       };
89945     } catch (std::exception& e) {
89946       {
89947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89948       };
89949     } catch (Dali::DaliException e) {
89950       {
89951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89952       };
89953     } catch (...) {
89954       {
89955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89956       };
89957     }
89958   }
89959
89960   jresult = (void *)result;
89961   return jresult;
89962 }
89963
89964
89965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89966   void * jresult ;
89967   std::vector< Dali::Actor > *arg1 = 0 ;
89968   std::vector< Dali::Actor > *result = 0 ;
89969
89970   arg1 = (std::vector< Dali::Actor > *)jarg1;
89971   if (!arg1) {
89972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89973     return 0;
89974   }
89975   {
89976     try {
89977       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89978     } catch (std::out_of_range& e) {
89979       {
89980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89981       };
89982     } catch (std::exception& e) {
89983       {
89984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89985       };
89986     } catch (Dali::DaliException e) {
89987       {
89988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89989       };
89990     } catch (...) {
89991       {
89992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89993       };
89994     }
89995   }
89996
89997   jresult = (void *)result;
89998   return jresult;
89999 }
90000
90001
90002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
90003   void * jresult ;
90004   int arg1 ;
90005   std::vector< Dali::Actor > *result = 0 ;
90006
90007   arg1 = (int)jarg1;
90008   {
90009     try {
90010       try {
90011         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
90012       }
90013       catch(std::out_of_range &_e) {
90014         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90015         return 0;
90016       }
90017
90018     } catch (std::out_of_range& e) {
90019       {
90020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90021       };
90022     } catch (std::exception& e) {
90023       {
90024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90025       };
90026     } catch (Dali::DaliException e) {
90027       {
90028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90029       };
90030     } catch (...) {
90031       {
90032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90033       };
90034     }
90035   }
90036
90037   jresult = (void *)result;
90038   return jresult;
90039 }
90040
90041
90042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
90043   void * jresult ;
90044   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90045   int arg2 ;
90046   Dali::Actor result;
90047
90048   arg1 = (std::vector< Dali::Actor > *)jarg1;
90049   arg2 = (int)jarg2;
90050   {
90051     try {
90052       try {
90053         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
90054       }
90055       catch(std::out_of_range &_e) {
90056         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90057         return 0;
90058       }
90059
90060     } catch (std::out_of_range& e) {
90061       {
90062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90063       };
90064     } catch (std::exception& e) {
90065       {
90066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90067       };
90068     } catch (Dali::DaliException e) {
90069       {
90070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90071       };
90072     } catch (...) {
90073       {
90074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90075       };
90076     }
90077   }
90078
90079   jresult = new Dali::Actor((const Dali::Actor &)result);
90080   return jresult;
90081 }
90082
90083
90084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
90085   void * jresult ;
90086   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90087   int arg2 ;
90088   Dali::Actor *result = 0 ;
90089
90090   arg1 = (std::vector< Dali::Actor > *)jarg1;
90091   arg2 = (int)jarg2;
90092   {
90093     try {
90094       try {
90095         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
90096       }
90097       catch(std::out_of_range &_e) {
90098         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90099         return 0;
90100       }
90101
90102     } catch (std::out_of_range& e) {
90103       {
90104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90105       };
90106     } catch (std::exception& e) {
90107       {
90108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90109       };
90110     } catch (Dali::DaliException e) {
90111       {
90112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90113       };
90114     } catch (...) {
90115       {
90116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90117       };
90118     }
90119   }
90120
90121   jresult = (void *)result;
90122   return jresult;
90123 }
90124
90125
90126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
90127   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90128   int arg2 ;
90129   Dali::Actor *arg3 = 0 ;
90130
90131   arg1 = (std::vector< Dali::Actor > *)jarg1;
90132   arg2 = (int)jarg2;
90133   arg3 = (Dali::Actor *)jarg3;
90134   if (!arg3) {
90135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
90136     return ;
90137   }
90138   {
90139     try {
90140       try {
90141         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
90142       }
90143       catch(std::out_of_range &_e) {
90144         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90145         return ;
90146       }
90147
90148     } catch (std::out_of_range& e) {
90149       {
90150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90151       };
90152     } catch (std::exception& e) {
90153       {
90154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90155       };
90156     } catch (Dali::DaliException e) {
90157       {
90158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90159       };
90160     } catch (...) {
90161       {
90162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90163       };
90164     }
90165   }
90166
90167 }
90168
90169
90170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
90171   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90172   std::vector< Dali::Actor > *arg2 = 0 ;
90173
90174   arg1 = (std::vector< Dali::Actor > *)jarg1;
90175   arg2 = (std::vector< Dali::Actor > *)jarg2;
90176   if (!arg2) {
90177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90178     return ;
90179   }
90180   {
90181     try {
90182       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
90183     } catch (std::out_of_range& e) {
90184       {
90185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90186       };
90187     } catch (std::exception& e) {
90188       {
90189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90190       };
90191     } catch (Dali::DaliException e) {
90192       {
90193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90194       };
90195     } catch (...) {
90196       {
90197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90198       };
90199     }
90200   }
90201
90202 }
90203
90204
90205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
90206   void * jresult ;
90207   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90208   int arg2 ;
90209   int arg3 ;
90210   std::vector< Dali::Actor > *result = 0 ;
90211
90212   arg1 = (std::vector< Dali::Actor > *)jarg1;
90213   arg2 = (int)jarg2;
90214   arg3 = (int)jarg3;
90215   {
90216     try {
90217       try {
90218         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
90219       }
90220       catch(std::out_of_range &_e) {
90221         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90222         return 0;
90223       }
90224       catch(std::invalid_argument &_e) {
90225         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90226         return 0;
90227       }
90228
90229     } catch (std::out_of_range& e) {
90230       {
90231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90232       };
90233     } catch (std::exception& e) {
90234       {
90235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90236       };
90237     } catch (Dali::DaliException e) {
90238       {
90239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90240       };
90241     } catch (...) {
90242       {
90243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90244       };
90245     }
90246   }
90247
90248   jresult = (void *)result;
90249   return jresult;
90250 }
90251
90252
90253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
90254   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90255   int arg2 ;
90256   Dali::Actor *arg3 = 0 ;
90257
90258   arg1 = (std::vector< Dali::Actor > *)jarg1;
90259   arg2 = (int)jarg2;
90260   arg3 = (Dali::Actor *)jarg3;
90261   if (!arg3) {
90262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
90263     return ;
90264   }
90265   {
90266     try {
90267       try {
90268         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
90269       }
90270       catch(std::out_of_range &_e) {
90271         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90272         return ;
90273       }
90274
90275     } catch (std::out_of_range& e) {
90276       {
90277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90278       };
90279     } catch (std::exception& e) {
90280       {
90281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90282       };
90283     } catch (Dali::DaliException e) {
90284       {
90285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90286       };
90287     } catch (...) {
90288       {
90289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90290       };
90291     }
90292   }
90293
90294 }
90295
90296
90297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
90298   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90299   int arg2 ;
90300   std::vector< Dali::Actor > *arg3 = 0 ;
90301
90302   arg1 = (std::vector< Dali::Actor > *)jarg1;
90303   arg2 = (int)jarg2;
90304   arg3 = (std::vector< Dali::Actor > *)jarg3;
90305   if (!arg3) {
90306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90307     return ;
90308   }
90309   {
90310     try {
90311       try {
90312         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90313       }
90314       catch(std::out_of_range &_e) {
90315         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90316         return ;
90317       }
90318
90319     } catch (std::out_of_range& e) {
90320       {
90321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90322       };
90323     } catch (std::exception& e) {
90324       {
90325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90326       };
90327     } catch (Dali::DaliException e) {
90328       {
90329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90330       };
90331     } catch (...) {
90332       {
90333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90334       };
90335     }
90336   }
90337
90338 }
90339
90340
90341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
90342   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90343   int arg2 ;
90344
90345   arg1 = (std::vector< Dali::Actor > *)jarg1;
90346   arg2 = (int)jarg2;
90347   {
90348     try {
90349       try {
90350         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
90351       }
90352       catch(std::out_of_range &_e) {
90353         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90354         return ;
90355       }
90356
90357     } catch (std::out_of_range& e) {
90358       {
90359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90360       };
90361     } catch (std::exception& e) {
90362       {
90363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90364       };
90365     } catch (Dali::DaliException e) {
90366       {
90367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90368       };
90369     } catch (...) {
90370       {
90371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90372       };
90373     }
90374   }
90375
90376 }
90377
90378
90379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
90380   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90381   int arg2 ;
90382   int arg3 ;
90383
90384   arg1 = (std::vector< Dali::Actor > *)jarg1;
90385   arg2 = (int)jarg2;
90386   arg3 = (int)jarg3;
90387   {
90388     try {
90389       try {
90390         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
90391       }
90392       catch(std::out_of_range &_e) {
90393         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90394         return ;
90395       }
90396       catch(std::invalid_argument &_e) {
90397         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90398         return ;
90399       }
90400
90401     } catch (std::out_of_range& e) {
90402       {
90403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90404       };
90405     } catch (std::exception& e) {
90406       {
90407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90408       };
90409     } catch (Dali::DaliException e) {
90410       {
90411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90412       };
90413     } catch (...) {
90414       {
90415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90416       };
90417     }
90418   }
90419
90420 }
90421
90422
90423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
90424   void * jresult ;
90425   Dali::Actor *arg1 = 0 ;
90426   int arg2 ;
90427   std::vector< Dali::Actor > *result = 0 ;
90428
90429   arg1 = (Dali::Actor *)jarg1;
90430   if (!arg1) {
90431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
90432     return 0;
90433   }
90434   arg2 = (int)jarg2;
90435   {
90436     try {
90437       try {
90438         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
90439       }
90440       catch(std::out_of_range &_e) {
90441         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90442         return 0;
90443       }
90444
90445     } catch (std::out_of_range& e) {
90446       {
90447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90448       };
90449     } catch (std::exception& e) {
90450       {
90451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90452       };
90453     } catch (Dali::DaliException e) {
90454       {
90455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90456       };
90457     } catch (...) {
90458       {
90459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90460       };
90461     }
90462   }
90463
90464   jresult = (void *)result;
90465   return jresult;
90466 }
90467
90468
90469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
90470   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90471
90472   arg1 = (std::vector< Dali::Actor > *)jarg1;
90473   {
90474     try {
90475       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
90476     } catch (std::out_of_range& e) {
90477       {
90478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90479       };
90480     } catch (std::exception& e) {
90481       {
90482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90483       };
90484     } catch (Dali::DaliException e) {
90485       {
90486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90487       };
90488     } catch (...) {
90489       {
90490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90491       };
90492     }
90493   }
90494
90495 }
90496
90497
90498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
90499   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90500   int arg2 ;
90501   int arg3 ;
90502
90503   arg1 = (std::vector< Dali::Actor > *)jarg1;
90504   arg2 = (int)jarg2;
90505   arg3 = (int)jarg3;
90506   {
90507     try {
90508       try {
90509         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
90510       }
90511       catch(std::out_of_range &_e) {
90512         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90513         return ;
90514       }
90515       catch(std::invalid_argument &_e) {
90516         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90517         return ;
90518       }
90519
90520     } catch (std::out_of_range& e) {
90521       {
90522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90523       };
90524     } catch (std::exception& e) {
90525       {
90526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90527       };
90528     } catch (Dali::DaliException e) {
90529       {
90530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90531       };
90532     } catch (...) {
90533       {
90534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90535       };
90536     }
90537   }
90538
90539 }
90540
90541
90542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
90543   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90544   int arg2 ;
90545   std::vector< Dali::Actor > *arg3 = 0 ;
90546
90547   arg1 = (std::vector< Dali::Actor > *)jarg1;
90548   arg2 = (int)jarg2;
90549   arg3 = (std::vector< Dali::Actor > *)jarg3;
90550   if (!arg3) {
90551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90552     return ;
90553   }
90554   {
90555     try {
90556       try {
90557         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90558       }
90559       catch(std::out_of_range &_e) {
90560         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90561         return ;
90562       }
90563
90564     } catch (std::out_of_range& e) {
90565       {
90566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90567       };
90568     } catch (std::exception& e) {
90569       {
90570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90571       };
90572     } catch (Dali::DaliException e) {
90573       {
90574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90575       };
90576     } catch (...) {
90577       {
90578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90579       };
90580     }
90581   }
90582
90583 }
90584
90585
90586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
90587   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90588
90589   arg1 = (std::vector< Dali::Actor > *)jarg1;
90590   {
90591     try {
90592       delete arg1;
90593     } catch (std::out_of_range& e) {
90594       {
90595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90596       };
90597     } catch (std::exception& e) {
90598       {
90599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90600       };
90601     } catch (Dali::DaliException e) {
90602       {
90603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90604       };
90605     } catch (...) {
90606       {
90607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90608       };
90609     }
90610   }
90611
90612 }
90613
90614
90615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
90616   unsigned int jresult ;
90617   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90618   bool result;
90619
90620   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90621   {
90622     try {
90623       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90624     } catch (std::out_of_range& e) {
90625       {
90626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90627       };
90628     } catch (std::exception& e) {
90629       {
90630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90631       };
90632     } catch (Dali::DaliException e) {
90633       {
90634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90635       };
90636     } catch (...) {
90637       {
90638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90639       };
90640     }
90641   }
90642
90643   jresult = result;
90644   return jresult;
90645 }
90646
90647
90648 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
90649   unsigned long jresult ;
90650   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90651   std::size_t result;
90652
90653   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90654   {
90655     try {
90656       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90657     } catch (std::out_of_range& e) {
90658       {
90659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90660       };
90661     } catch (std::exception& e) {
90662       {
90663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90664       };
90665     } catch (Dali::DaliException e) {
90666       {
90667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90668       };
90669     } catch (...) {
90670       {
90671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90672       };
90673     }
90674   }
90675
90676   jresult = (unsigned long)result;
90677   return jresult;
90678 }
90679
90680
90681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90682   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90683   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90684
90685   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90686   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90687   {
90688     try {
90689       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90690     } catch (std::out_of_range& e) {
90691       {
90692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90693       };
90694     } catch (std::exception& e) {
90695       {
90696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90697       };
90698     } catch (Dali::DaliException e) {
90699       {
90700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90701       };
90702     } catch (...) {
90703       {
90704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90705       };
90706     }
90707   }
90708
90709 }
90710
90711
90712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90713   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90714   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90715
90716   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90717   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90718   {
90719     try {
90720       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90721     } catch (std::out_of_range& e) {
90722       {
90723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90724       };
90725     } catch (std::exception& e) {
90726       {
90727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90728       };
90729     } catch (Dali::DaliException e) {
90730       {
90731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90732       };
90733     } catch (...) {
90734       {
90735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90736       };
90737     }
90738   }
90739
90740 }
90741
90742
90743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90744   unsigned int jresult ;
90745   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90746   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90747   bool result;
90748
90749   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90750   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90751   if (!arg2) {
90752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90753     return 0;
90754   }
90755   {
90756     try {
90757       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90758     } catch (std::out_of_range& e) {
90759       {
90760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90761       };
90762     } catch (std::exception& e) {
90763       {
90764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90765       };
90766     } catch (Dali::DaliException e) {
90767       {
90768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90769       };
90770     } catch (...) {
90771       {
90772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90773       };
90774     }
90775   }
90776
90777   jresult = result;
90778   return jresult;
90779 }
90780
90781
90782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90783   void * jresult ;
90784   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90785
90786   {
90787     try {
90788       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90789     } catch (std::out_of_range& e) {
90790       {
90791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90792       };
90793     } catch (std::exception& e) {
90794       {
90795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90796       };
90797     } catch (Dali::DaliException e) {
90798       {
90799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90800       };
90801     } catch (...) {
90802       {
90803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90804       };
90805     }
90806   }
90807
90808   jresult = (void *)result;
90809   return jresult;
90810 }
90811
90812
90813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90814   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90815
90816   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90817   {
90818     try {
90819       delete arg1;
90820     } catch (std::out_of_range& e) {
90821       {
90822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90823       };
90824     } catch (std::exception& e) {
90825       {
90826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90827       };
90828     } catch (Dali::DaliException e) {
90829       {
90830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90831       };
90832     } catch (...) {
90833       {
90834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90835       };
90836     }
90837   }
90838
90839 }
90840
90841
90842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90843   unsigned int jresult ;
90844   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90845   bool result;
90846
90847   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90848   {
90849     try {
90850       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);
90851     } catch (std::out_of_range& e) {
90852       {
90853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90854       };
90855     } catch (std::exception& e) {
90856       {
90857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90858       };
90859     } catch (Dali::DaliException e) {
90860       {
90861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90862       };
90863     } catch (...) {
90864       {
90865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90866       };
90867     }
90868   }
90869
90870   jresult = result;
90871   return jresult;
90872 }
90873
90874
90875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90876   unsigned long jresult ;
90877   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90878   std::size_t result;
90879
90880   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90881   {
90882     try {
90883       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);
90884     } catch (std::out_of_range& e) {
90885       {
90886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90887       };
90888     } catch (std::exception& e) {
90889       {
90890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90891       };
90892     } catch (Dali::DaliException e) {
90893       {
90894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90895       };
90896     } catch (...) {
90897       {
90898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90899       };
90900     }
90901   }
90902
90903   jresult = (unsigned long)result;
90904   return jresult;
90905 }
90906
90907
90908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90909   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90910   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90911
90912   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90913   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90914   {
90915     try {
90916       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90917     } catch (std::out_of_range& e) {
90918       {
90919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90920       };
90921     } catch (std::exception& e) {
90922       {
90923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90924       };
90925     } catch (Dali::DaliException e) {
90926       {
90927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90928       };
90929     } catch (...) {
90930       {
90931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90932       };
90933     }
90934   }
90935
90936 }
90937
90938
90939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90940   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90941   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90942
90943   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90944   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90945   {
90946     try {
90947       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90948     } catch (std::out_of_range& e) {
90949       {
90950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90951       };
90952     } catch (std::exception& e) {
90953       {
90954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90955       };
90956     } catch (Dali::DaliException e) {
90957       {
90958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90959       };
90960     } catch (...) {
90961       {
90962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90963       };
90964     }
90965   }
90966
90967 }
90968
90969
90970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90971   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90972   Dali::Actor arg2 ;
90973   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90974   Dali::Actor *argp2 ;
90975
90976   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90977   argp2 = (Dali::Actor *)jarg2;
90978   if (!argp2) {
90979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90980     return ;
90981   }
90982   arg2 = *argp2;
90983   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90984   {
90985     try {
90986       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90987     } catch (std::out_of_range& e) {
90988       {
90989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90990       };
90991     } catch (std::exception& e) {
90992       {
90993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90994       };
90995     } catch (Dali::DaliException e) {
90996       {
90997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90998       };
90999     } catch (...) {
91000       {
91001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91002       };
91003     }
91004   }
91005
91006 }
91007
91008
91009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
91010   void * jresult ;
91011   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
91012
91013   {
91014     try {
91015       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
91016     } catch (std::out_of_range& e) {
91017       {
91018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91019       };
91020     } catch (std::exception& e) {
91021       {
91022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91023       };
91024     } catch (Dali::DaliException e) {
91025       {
91026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91027       };
91028     } catch (...) {
91029       {
91030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91031       };
91032     }
91033   }
91034
91035   jresult = (void *)result;
91036   return jresult;
91037 }
91038
91039
91040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
91041   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
91042
91043   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
91044   {
91045     try {
91046       delete arg1;
91047     } catch (std::out_of_range& e) {
91048       {
91049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91050       };
91051     } catch (std::exception& e) {
91052       {
91053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91054       };
91055     } catch (Dali::DaliException e) {
91056       {
91057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91058       };
91059     } catch (...) {
91060       {
91061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91062       };
91063     }
91064   }
91065
91066 }
91067
91068
91069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
91070   unsigned int jresult ;
91071   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
91072   bool result;
91073
91074   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
91075   {
91076     try {
91077       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
91078     } catch (std::out_of_range& e) {
91079       {
91080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91081       };
91082     } catch (std::exception& e) {
91083       {
91084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91085       };
91086     } catch (Dali::DaliException e) {
91087       {
91088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91089       };
91090     } catch (...) {
91091       {
91092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91093       };
91094     }
91095   }
91096
91097   jresult = result;
91098   return jresult;
91099 }
91100
91101
91102 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
91103   unsigned long jresult ;
91104   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
91105   std::size_t result;
91106
91107   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
91108   {
91109     try {
91110       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
91111     } catch (std::out_of_range& e) {
91112       {
91113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91114       };
91115     } catch (std::exception& e) {
91116       {
91117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91118       };
91119     } catch (Dali::DaliException e) {
91120       {
91121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91122       };
91123     } catch (...) {
91124       {
91125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91126       };
91127     }
91128   }
91129
91130   jresult = (unsigned long)result;
91131   return jresult;
91132 }
91133
91134
91135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
91136   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
91137   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
91138
91139   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
91140   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
91141   {
91142     try {
91143       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
91144     } catch (std::out_of_range& e) {
91145       {
91146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91147       };
91148     } catch (std::exception& e) {
91149       {
91150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91151       };
91152     } catch (Dali::DaliException e) {
91153       {
91154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91155       };
91156     } catch (...) {
91157       {
91158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91159       };
91160     }
91161   }
91162
91163 }
91164
91165
91166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91167   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
91168   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
91169
91170   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
91171   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
91172   {
91173     try {
91174       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
91175     } catch (std::out_of_range& e) {
91176       {
91177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91178       };
91179     } catch (std::exception& e) {
91180       {
91181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91182       };
91183     } catch (Dali::DaliException e) {
91184       {
91185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91186       };
91187     } catch (...) {
91188       {
91189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91190       };
91191     }
91192   }
91193
91194 }
91195
91196
91197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91198   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
91199   Dali::Actor arg2 ;
91200   Dali::Actor arg3 ;
91201   Dali::Actor *argp2 ;
91202   Dali::Actor *argp3 ;
91203
91204   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
91205   argp2 = (Dali::Actor *)jarg2;
91206   if (!argp2) {
91207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91208     return ;
91209   }
91210   arg2 = *argp2;
91211   argp3 = (Dali::Actor *)jarg3;
91212   if (!argp3) {
91213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91214     return ;
91215   }
91216   arg3 = *argp3;
91217   {
91218     try {
91219       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
91220     } catch (std::out_of_range& e) {
91221       {
91222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91223       };
91224     } catch (std::exception& e) {
91225       {
91226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91227       };
91228     } catch (Dali::DaliException e) {
91229       {
91230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91231       };
91232     } catch (...) {
91233       {
91234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91235       };
91236     }
91237   }
91238
91239 }
91240
91241
91242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
91243   void * jresult ;
91244   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
91245
91246   {
91247     try {
91248       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
91249     } catch (std::out_of_range& e) {
91250       {
91251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91252       };
91253     } catch (std::exception& e) {
91254       {
91255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91256       };
91257     } catch (Dali::DaliException e) {
91258       {
91259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91260       };
91261     } catch (...) {
91262       {
91263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91264       };
91265     }
91266   }
91267
91268   jresult = (void *)result;
91269   return jresult;
91270 }
91271
91272
91273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
91274   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
91275
91276   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
91277   {
91278     try {
91279       delete arg1;
91280     } catch (std::out_of_range& e) {
91281       {
91282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91283       };
91284     } catch (std::exception& e) {
91285       {
91286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91287       };
91288     } catch (Dali::DaliException e) {
91289       {
91290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91291       };
91292     } catch (...) {
91293       {
91294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91295       };
91296     }
91297   }
91298
91299 }
91300
91301
91302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
91303   unsigned int jresult ;
91304   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91305   bool result;
91306
91307   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91308   {
91309     try {
91310       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
91311     } catch (std::out_of_range& e) {
91312       {
91313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91314       };
91315     } catch (std::exception& e) {
91316       {
91317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91318       };
91319     } catch (Dali::DaliException e) {
91320       {
91321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91322       };
91323     } catch (...) {
91324       {
91325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91326       };
91327     }
91328   }
91329
91330   jresult = result;
91331   return jresult;
91332 }
91333
91334
91335 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
91336   unsigned long jresult ;
91337   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91338   std::size_t result;
91339
91340   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91341   {
91342     try {
91343       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
91344     } catch (std::out_of_range& e) {
91345       {
91346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91347       };
91348     } catch (std::exception& e) {
91349       {
91350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91351       };
91352     } catch (Dali::DaliException e) {
91353       {
91354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91355       };
91356     } catch (...) {
91357       {
91358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91359       };
91360     }
91361   }
91362
91363   jresult = (unsigned long)result;
91364   return jresult;
91365 }
91366
91367
91368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
91369   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91370   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
91371
91372   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91373   arg2 = (void (*)(Dali::Actor,bool))jarg2;
91374   {
91375     try {
91376       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
91377     } catch (std::out_of_range& e) {
91378       {
91379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91380       };
91381     } catch (std::exception& e) {
91382       {
91383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91384       };
91385     } catch (Dali::DaliException e) {
91386       {
91387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91388       };
91389     } catch (...) {
91390       {
91391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91392       };
91393     }
91394   }
91395
91396 }
91397
91398
91399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91400   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91401   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
91402
91403   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91404   arg2 = (void (*)(Dali::Actor,bool))jarg2;
91405   {
91406     try {
91407       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91408     } catch (std::out_of_range& e) {
91409       {
91410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91411       };
91412     } catch (std::exception& e) {
91413       {
91414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91415       };
91416     } catch (Dali::DaliException e) {
91417       {
91418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91419       };
91420     } catch (...) {
91421       {
91422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91423       };
91424     }
91425   }
91426
91427 }
91428
91429
91430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
91431   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91432   Dali::Actor arg2 ;
91433   bool arg3 ;
91434   Dali::Actor *argp2 ;
91435
91436   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91437   argp2 = (Dali::Actor *)jarg2;
91438   if (!argp2) {
91439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91440     return ;
91441   }
91442   arg2 = *argp2;
91443   arg3 = jarg3 ? true : false;
91444   {
91445     try {
91446       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
91447     } catch (std::out_of_range& e) {
91448       {
91449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91450       };
91451     } catch (std::exception& e) {
91452       {
91453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91454       };
91455     } catch (Dali::DaliException e) {
91456       {
91457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91458       };
91459     } catch (...) {
91460       {
91461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91462       };
91463     }
91464   }
91465
91466 }
91467
91468
91469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
91470   void * jresult ;
91471   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
91472
91473   {
91474     try {
91475       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
91476     } catch (std::out_of_range& e) {
91477       {
91478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91479       };
91480     } catch (std::exception& e) {
91481       {
91482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91483       };
91484     } catch (Dali::DaliException e) {
91485       {
91486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91487       };
91488     } catch (...) {
91489       {
91490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91491       };
91492     }
91493   }
91494
91495   jresult = (void *)result;
91496   return jresult;
91497 }
91498
91499
91500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
91501   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91502
91503   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91504   {
91505     try {
91506       delete arg1;
91507     } catch (std::out_of_range& e) {
91508       {
91509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91510       };
91511     } catch (std::exception& e) {
91512       {
91513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91514       };
91515     } catch (Dali::DaliException e) {
91516       {
91517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91518       };
91519     } catch (...) {
91520       {
91521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91522       };
91523     }
91524   }
91525
91526 }
91527
91528
91529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
91530   unsigned int jresult ;
91531   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91532   bool result;
91533
91534   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91535   {
91536     try {
91537       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);
91538     } catch (std::out_of_range& e) {
91539       {
91540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91541       };
91542     } catch (std::exception& e) {
91543       {
91544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91545       };
91546     } catch (Dali::DaliException e) {
91547       {
91548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91549       };
91550     } catch (...) {
91551       {
91552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91553       };
91554     }
91555   }
91556
91557   jresult = result;
91558   return jresult;
91559 }
91560
91561
91562 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
91563   unsigned long jresult ;
91564   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91565   std::size_t result;
91566
91567   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91568   {
91569     try {
91570       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);
91571     } catch (std::out_of_range& e) {
91572       {
91573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91574       };
91575     } catch (std::exception& e) {
91576       {
91577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91578       };
91579     } catch (Dali::DaliException e) {
91580       {
91581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91582       };
91583     } catch (...) {
91584       {
91585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91586       };
91587     }
91588   }
91589
91590   jresult = (unsigned long)result;
91591   return jresult;
91592 }
91593
91594
91595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
91596   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91597   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91598
91599   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91600   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91601   {
91602     try {
91603       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
91604     } catch (std::out_of_range& e) {
91605       {
91606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91607       };
91608     } catch (std::exception& e) {
91609       {
91610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91611       };
91612     } catch (Dali::DaliException e) {
91613       {
91614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91615       };
91616     } catch (...) {
91617       {
91618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91619       };
91620     }
91621   }
91622
91623 }
91624
91625
91626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91627   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91628   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91629
91630   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91631   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91632   {
91633     try {
91634       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
91635     } catch (std::out_of_range& e) {
91636       {
91637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91638       };
91639     } catch (std::exception& e) {
91640       {
91641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91642       };
91643     } catch (Dali::DaliException e) {
91644       {
91645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91646       };
91647     } catch (...) {
91648       {
91649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91650       };
91651     }
91652   }
91653
91654 }
91655
91656
91657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91658   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91659   Dali::Toolkit::StyleManager arg2 ;
91660   Dali::StyleChange::Type arg3 ;
91661   Dali::Toolkit::StyleManager *argp2 ;
91662
91663   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91664   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91665   if (!argp2) {
91666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91667     return ;
91668   }
91669   arg2 = *argp2;
91670   arg3 = (Dali::StyleChange::Type)jarg3;
91671   {
91672     try {
91673       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91674     } catch (std::out_of_range& e) {
91675       {
91676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91677       };
91678     } catch (std::exception& e) {
91679       {
91680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91681       };
91682     } catch (Dali::DaliException e) {
91683       {
91684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91685       };
91686     } catch (...) {
91687       {
91688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91689       };
91690     }
91691   }
91692
91693 }
91694
91695
91696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91697   void * jresult ;
91698   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91699
91700   {
91701     try {
91702       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91703     } catch (std::out_of_range& e) {
91704       {
91705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91706       };
91707     } catch (std::exception& e) {
91708       {
91709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91710       };
91711     } catch (Dali::DaliException e) {
91712       {
91713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91714       };
91715     } catch (...) {
91716       {
91717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91718       };
91719     }
91720   }
91721
91722   jresult = (void *)result;
91723   return jresult;
91724 }
91725
91726
91727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91728   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91729
91730   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91731   {
91732     try {
91733       delete arg1;
91734     } catch (std::out_of_range& e) {
91735       {
91736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91737       };
91738     } catch (std::exception& e) {
91739       {
91740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91741       };
91742     } catch (Dali::DaliException e) {
91743       {
91744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91745       };
91746     } catch (...) {
91747       {
91748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91749       };
91750     }
91751   }
91752
91753 }
91754
91755
91756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91757   unsigned int jresult ;
91758   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91759   bool result;
91760
91761   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91762   {
91763     try {
91764       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91765     } catch (std::out_of_range& e) {
91766       {
91767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91768       };
91769     } catch (std::exception& e) {
91770       {
91771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91772       };
91773     } catch (Dali::DaliException e) {
91774       {
91775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91776       };
91777     } catch (...) {
91778       {
91779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91780       };
91781     }
91782   }
91783
91784   jresult = result;
91785   return jresult;
91786 }
91787
91788
91789 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91790   unsigned long jresult ;
91791   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91792   std::size_t result;
91793
91794   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91795   {
91796     try {
91797       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91798     } catch (std::out_of_range& e) {
91799       {
91800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91801       };
91802     } catch (std::exception& e) {
91803       {
91804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91805       };
91806     } catch (Dali::DaliException e) {
91807       {
91808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91809       };
91810     } catch (...) {
91811       {
91812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91813       };
91814     }
91815   }
91816
91817   jresult = (unsigned long)result;
91818   return jresult;
91819 }
91820
91821
91822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91823   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91824   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91825
91826   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91827   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91828   {
91829     try {
91830       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91831     } catch (std::out_of_range& e) {
91832       {
91833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91834       };
91835     } catch (std::exception& e) {
91836       {
91837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91838       };
91839     } catch (Dali::DaliException e) {
91840       {
91841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91842       };
91843     } catch (...) {
91844       {
91845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91846       };
91847     }
91848   }
91849
91850 }
91851
91852
91853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91854   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91855   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91856
91857   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91858   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91859   {
91860     try {
91861       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91862     } catch (std::out_of_range& e) {
91863       {
91864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91865       };
91866     } catch (std::exception& e) {
91867       {
91868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91869       };
91870     } catch (Dali::DaliException e) {
91871       {
91872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91873       };
91874     } catch (...) {
91875       {
91876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91877       };
91878     }
91879   }
91880
91881 }
91882
91883
91884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91885   unsigned int jresult ;
91886   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91887   Dali::Toolkit::Button arg2 ;
91888   Dali::Toolkit::Button *argp2 ;
91889   bool result;
91890
91891   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91892   argp2 = (Dali::Toolkit::Button *)jarg2;
91893   if (!argp2) {
91894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91895     return 0;
91896   }
91897   arg2 = *argp2;
91898   {
91899     try {
91900       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91901     } catch (std::out_of_range& e) {
91902       {
91903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91904       };
91905     } catch (std::exception& e) {
91906       {
91907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91908       };
91909     } catch (Dali::DaliException e) {
91910       {
91911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91912       };
91913     } catch (...) {
91914       {
91915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91916       };
91917     }
91918   }
91919
91920   jresult = result;
91921   return jresult;
91922 }
91923
91924
91925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91926   void * jresult ;
91927   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91928
91929   {
91930     try {
91931       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91932     } catch (std::out_of_range& e) {
91933       {
91934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91935       };
91936     } catch (std::exception& e) {
91937       {
91938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91939       };
91940     } catch (Dali::DaliException e) {
91941       {
91942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91943       };
91944     } catch (...) {
91945       {
91946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91947       };
91948     }
91949   }
91950
91951   jresult = (void *)result;
91952   return jresult;
91953 }
91954
91955
91956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91957   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91958
91959   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91960   {
91961     try {
91962       delete arg1;
91963     } catch (std::out_of_range& e) {
91964       {
91965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91966       };
91967     } catch (std::exception& e) {
91968       {
91969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91970       };
91971     } catch (Dali::DaliException e) {
91972       {
91973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91974       };
91975     } catch (...) {
91976       {
91977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91978       };
91979     }
91980   }
91981
91982 }
91983
91984
91985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91986   unsigned int jresult ;
91987   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91988   bool result;
91989
91990   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91991   {
91992     try {
91993       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91994     } catch (std::out_of_range& e) {
91995       {
91996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91997       };
91998     } catch (std::exception& e) {
91999       {
92000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92001       };
92002     } catch (Dali::DaliException e) {
92003       {
92004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92005       };
92006     } catch (...) {
92007       {
92008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92009       };
92010     }
92011   }
92012
92013   jresult = result;
92014   return jresult;
92015 }
92016
92017
92018 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
92019   unsigned long jresult ;
92020   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
92021   std::size_t result;
92022
92023   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
92024   {
92025     try {
92026       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
92027     } catch (std::out_of_range& e) {
92028       {
92029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92030       };
92031     } catch (std::exception& e) {
92032       {
92033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92034       };
92035     } catch (Dali::DaliException e) {
92036       {
92037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92038       };
92039     } catch (...) {
92040       {
92041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92042       };
92043     }
92044   }
92045
92046   jresult = (unsigned long)result;
92047   return jresult;
92048 }
92049
92050
92051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
92052   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
92053   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
92054
92055   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
92056   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
92057   {
92058     try {
92059       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
92060     } catch (std::out_of_range& e) {
92061       {
92062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92063       };
92064     } catch (std::exception& e) {
92065       {
92066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92067       };
92068     } catch (Dali::DaliException e) {
92069       {
92070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92071       };
92072     } catch (...) {
92073       {
92074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92075       };
92076     }
92077   }
92078
92079 }
92080
92081
92082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
92083   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
92084   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
92085
92086   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
92087   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
92088   {
92089     try {
92090       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
92091     } catch (std::out_of_range& e) {
92092       {
92093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92094       };
92095     } catch (std::exception& e) {
92096       {
92097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92098       };
92099     } catch (Dali::DaliException e) {
92100       {
92101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92102       };
92103     } catch (...) {
92104       {
92105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92106       };
92107     }
92108   }
92109
92110 }
92111
92112
92113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
92114   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
92115   Dali::Toolkit::GaussianBlurView arg2 ;
92116   Dali::Toolkit::GaussianBlurView *argp2 ;
92117
92118   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
92119   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
92120   if (!argp2) {
92121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
92122     return ;
92123   }
92124   arg2 = *argp2;
92125   {
92126     try {
92127       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
92128     } catch (std::out_of_range& e) {
92129       {
92130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92131       };
92132     } catch (std::exception& e) {
92133       {
92134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92135       };
92136     } catch (Dali::DaliException e) {
92137       {
92138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92139       };
92140     } catch (...) {
92141       {
92142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92143       };
92144     }
92145   }
92146
92147 }
92148
92149
92150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
92151   void * jresult ;
92152   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
92153
92154   {
92155     try {
92156       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
92157     } catch (std::out_of_range& e) {
92158       {
92159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92160       };
92161     } catch (std::exception& e) {
92162       {
92163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92164       };
92165     } catch (Dali::DaliException e) {
92166       {
92167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92168       };
92169     } catch (...) {
92170       {
92171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92172       };
92173     }
92174   }
92175
92176   jresult = (void *)result;
92177   return jresult;
92178 }
92179
92180
92181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
92182   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
92183
92184   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
92185   {
92186     try {
92187       delete arg1;
92188     } catch (std::out_of_range& e) {
92189       {
92190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92191       };
92192     } catch (std::exception& e) {
92193       {
92194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92195       };
92196     } catch (Dali::DaliException e) {
92197       {
92198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92199       };
92200     } catch (...) {
92201       {
92202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92203       };
92204     }
92205   }
92206
92207 }
92208
92209
92210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
92211   unsigned int jresult ;
92212   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92213   bool result;
92214
92215   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92216   {
92217     try {
92218       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);
92219     } catch (std::out_of_range& e) {
92220       {
92221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92222       };
92223     } catch (std::exception& e) {
92224       {
92225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92226       };
92227     } catch (Dali::DaliException e) {
92228       {
92229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92230       };
92231     } catch (...) {
92232       {
92233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92234       };
92235     }
92236   }
92237
92238   jresult = result;
92239   return jresult;
92240 }
92241
92242
92243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
92244   unsigned long jresult ;
92245   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92246   std::size_t result;
92247
92248   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92249   {
92250     try {
92251       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);
92252     } catch (std::out_of_range& e) {
92253       {
92254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92255       };
92256     } catch (std::exception& e) {
92257       {
92258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92259       };
92260     } catch (Dali::DaliException e) {
92261       {
92262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92263       };
92264     } catch (...) {
92265       {
92266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92267       };
92268     }
92269   }
92270
92271   jresult = (unsigned long)result;
92272   return jresult;
92273 }
92274
92275
92276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
92277   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92278   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
92279
92280   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92281   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
92282   {
92283     try {
92284       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
92285     } catch (std::out_of_range& e) {
92286       {
92287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92288       };
92289     } catch (std::exception& e) {
92290       {
92291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92292       };
92293     } catch (Dali::DaliException e) {
92294       {
92295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92296       };
92297     } catch (...) {
92298       {
92299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92300       };
92301     }
92302   }
92303
92304 }
92305
92306
92307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
92308   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92309   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
92310
92311   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92312   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
92313   {
92314     try {
92315       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
92316     } catch (std::out_of_range& e) {
92317       {
92318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92319       };
92320     } catch (std::exception& e) {
92321       {
92322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92323       };
92324     } catch (Dali::DaliException e) {
92325       {
92326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92327       };
92328     } catch (...) {
92329       {
92330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92331       };
92332     }
92333   }
92334
92335 }
92336
92337
92338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
92339   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92340   Dali::Toolkit::PageTurnView arg2 ;
92341   unsigned int arg3 ;
92342   bool arg4 ;
92343   Dali::Toolkit::PageTurnView *argp2 ;
92344
92345   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92346   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92347   if (!argp2) {
92348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92349     return ;
92350   }
92351   arg2 = *argp2;
92352   arg3 = (unsigned int)jarg3;
92353   arg4 = jarg4 ? true : false;
92354   {
92355     try {
92356       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92357     } catch (std::out_of_range& e) {
92358       {
92359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92360       };
92361     } catch (std::exception& e) {
92362       {
92363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92364       };
92365     } catch (Dali::DaliException e) {
92366       {
92367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92368       };
92369     } catch (...) {
92370       {
92371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92372       };
92373     }
92374   }
92375
92376 }
92377
92378
92379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
92380   void * jresult ;
92381   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
92382
92383   {
92384     try {
92385       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
92386     } catch (std::out_of_range& e) {
92387       {
92388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92389       };
92390     } catch (std::exception& e) {
92391       {
92392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92393       };
92394     } catch (Dali::DaliException e) {
92395       {
92396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92397       };
92398     } catch (...) {
92399       {
92400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92401       };
92402     }
92403   }
92404
92405   jresult = (void *)result;
92406   return jresult;
92407 }
92408
92409
92410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
92411   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92412
92413   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92414   {
92415     try {
92416       delete arg1;
92417     } catch (std::out_of_range& e) {
92418       {
92419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92420       };
92421     } catch (std::exception& e) {
92422       {
92423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92424       };
92425     } catch (Dali::DaliException e) {
92426       {
92427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92428       };
92429     } catch (...) {
92430       {
92431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92432       };
92433     }
92434   }
92435
92436 }
92437
92438
92439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
92440   unsigned int jresult ;
92441   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92442   bool result;
92443
92444   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92445   {
92446     try {
92447       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
92448     } catch (std::out_of_range& e) {
92449       {
92450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92451       };
92452     } catch (std::exception& e) {
92453       {
92454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92455       };
92456     } catch (Dali::DaliException e) {
92457       {
92458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92459       };
92460     } catch (...) {
92461       {
92462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92463       };
92464     }
92465   }
92466
92467   jresult = result;
92468   return jresult;
92469 }
92470
92471
92472 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
92473   unsigned long jresult ;
92474   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92475   std::size_t result;
92476
92477   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92478   {
92479     try {
92480       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
92481     } catch (std::out_of_range& e) {
92482       {
92483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92484       };
92485     } catch (std::exception& e) {
92486       {
92487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92488       };
92489     } catch (Dali::DaliException e) {
92490       {
92491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92492       };
92493     } catch (...) {
92494       {
92495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92496       };
92497     }
92498   }
92499
92500   jresult = (unsigned long)result;
92501   return jresult;
92502 }
92503
92504
92505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
92506   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92507   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92508
92509   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92510   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92511   {
92512     try {
92513       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
92514     } catch (std::out_of_range& e) {
92515       {
92516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92517       };
92518     } catch (std::exception& e) {
92519       {
92520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92521       };
92522     } catch (Dali::DaliException e) {
92523       {
92524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92525       };
92526     } catch (...) {
92527       {
92528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92529       };
92530     }
92531   }
92532
92533 }
92534
92535
92536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
92537   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92538   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92539
92540   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92541   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92542   {
92543     try {
92544       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
92545     } catch (std::out_of_range& e) {
92546       {
92547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92548       };
92549     } catch (std::exception& e) {
92550       {
92551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92552       };
92553     } catch (Dali::DaliException e) {
92554       {
92555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92556       };
92557     } catch (...) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92560       };
92561     }
92562   }
92563
92564 }
92565
92566
92567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
92568   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92569   Dali::Toolkit::PageTurnView arg2 ;
92570   Dali::Toolkit::PageTurnView *argp2 ;
92571
92572   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92573   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92574   if (!argp2) {
92575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92576     return ;
92577   }
92578   arg2 = *argp2;
92579   {
92580     try {
92581       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
92582     } catch (std::out_of_range& e) {
92583       {
92584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92585       };
92586     } catch (std::exception& e) {
92587       {
92588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92589       };
92590     } catch (Dali::DaliException e) {
92591       {
92592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92593       };
92594     } catch (...) {
92595       {
92596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92597       };
92598     }
92599   }
92600
92601 }
92602
92603
92604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
92605   void * jresult ;
92606   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
92607
92608   {
92609     try {
92610       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
92611     } catch (std::out_of_range& e) {
92612       {
92613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92614       };
92615     } catch (std::exception& e) {
92616       {
92617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92618       };
92619     } catch (Dali::DaliException e) {
92620       {
92621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92622       };
92623     } catch (...) {
92624       {
92625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92626       };
92627     }
92628   }
92629
92630   jresult = (void *)result;
92631   return jresult;
92632 }
92633
92634
92635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
92636   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92637
92638   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92639   {
92640     try {
92641       delete arg1;
92642     } catch (std::out_of_range& e) {
92643       {
92644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92645       };
92646     } catch (std::exception& e) {
92647       {
92648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92649       };
92650     } catch (Dali::DaliException e) {
92651       {
92652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92653       };
92654     } catch (...) {
92655       {
92656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92657       };
92658     }
92659   }
92660
92661 }
92662
92663
92664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92665   unsigned int jresult ;
92666   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92667   bool result;
92668
92669   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92670   {
92671     try {
92672       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);
92673     } catch (std::out_of_range& e) {
92674       {
92675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92676       };
92677     } catch (std::exception& e) {
92678       {
92679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92680       };
92681     } catch (Dali::DaliException e) {
92682       {
92683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92684       };
92685     } catch (...) {
92686       {
92687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92688       };
92689     }
92690   }
92691
92692   jresult = result;
92693   return jresult;
92694 }
92695
92696
92697 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92698   unsigned long jresult ;
92699   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92700   std::size_t result;
92701
92702   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92703   {
92704     try {
92705       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);
92706     } catch (std::out_of_range& e) {
92707       {
92708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92709       };
92710     } catch (std::exception& e) {
92711       {
92712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92713       };
92714     } catch (Dali::DaliException e) {
92715       {
92716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92717       };
92718     } catch (...) {
92719       {
92720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92721       };
92722     }
92723   }
92724
92725   jresult = (unsigned long)result;
92726   return jresult;
92727 }
92728
92729
92730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92731   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92732   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92733
92734   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92735   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92736   {
92737     try {
92738       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92739     } catch (std::out_of_range& e) {
92740       {
92741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92742       };
92743     } catch (std::exception& e) {
92744       {
92745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92746       };
92747     } catch (Dali::DaliException e) {
92748       {
92749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92750       };
92751     } catch (...) {
92752       {
92753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92754       };
92755     }
92756   }
92757
92758 }
92759
92760
92761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92762   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92763   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92764
92765   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92766   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92767   {
92768     try {
92769       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92770     } catch (std::out_of_range& e) {
92771       {
92772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92773       };
92774     } catch (std::exception& e) {
92775       {
92776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92777       };
92778     } catch (Dali::DaliException e) {
92779       {
92780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92781       };
92782     } catch (...) {
92783       {
92784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92785       };
92786     }
92787   }
92788
92789 }
92790
92791
92792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92793   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92794   Dali::Toolkit::ProgressBar arg2 ;
92795   float arg3 ;
92796   float arg4 ;
92797   Dali::Toolkit::ProgressBar *argp2 ;
92798
92799   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92800   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92801   if (!argp2) {
92802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92803     return ;
92804   }
92805   arg2 = *argp2;
92806   arg3 = (float)jarg3;
92807   arg4 = (float)jarg4;
92808   {
92809     try {
92810       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92811     } catch (std::out_of_range& e) {
92812       {
92813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92814       };
92815     } catch (std::exception& e) {
92816       {
92817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92818       };
92819     } catch (Dali::DaliException e) {
92820       {
92821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92822       };
92823     } catch (...) {
92824       {
92825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92826       };
92827     }
92828   }
92829
92830 }
92831
92832
92833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92834   void * jresult ;
92835   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92836
92837   {
92838     try {
92839       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92840     } catch (std::out_of_range& e) {
92841       {
92842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92843       };
92844     } catch (std::exception& e) {
92845       {
92846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92847       };
92848     } catch (Dali::DaliException e) {
92849       {
92850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92851       };
92852     } catch (...) {
92853       {
92854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92855       };
92856     }
92857   }
92858
92859   jresult = (void *)result;
92860   return jresult;
92861 }
92862
92863
92864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92865   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92866
92867   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92868   {
92869     try {
92870       delete arg1;
92871     } catch (std::out_of_range& e) {
92872       {
92873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92874       };
92875     } catch (std::exception& e) {
92876       {
92877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92878       };
92879     } catch (Dali::DaliException e) {
92880       {
92881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92882       };
92883     } catch (...) {
92884       {
92885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92886       };
92887     }
92888   }
92889
92890 }
92891
92892
92893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92894   unsigned int jresult ;
92895   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92896   bool result;
92897
92898   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92899   {
92900     try {
92901       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);
92902     } catch (std::out_of_range& e) {
92903       {
92904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92905       };
92906     } catch (std::exception& e) {
92907       {
92908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92909       };
92910     } catch (Dali::DaliException e) {
92911       {
92912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92913       };
92914     } catch (...) {
92915       {
92916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92917       };
92918     }
92919   }
92920
92921   jresult = result;
92922   return jresult;
92923 }
92924
92925
92926 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92927   unsigned long jresult ;
92928   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92929   std::size_t result;
92930
92931   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92932   {
92933     try {
92934       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);
92935     } catch (std::out_of_range& e) {
92936       {
92937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92938       };
92939     } catch (std::exception& e) {
92940       {
92941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92942       };
92943     } catch (Dali::DaliException e) {
92944       {
92945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92946       };
92947     } catch (...) {
92948       {
92949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92950       };
92951     }
92952   }
92953
92954   jresult = (unsigned long)result;
92955   return jresult;
92956 }
92957
92958
92959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92960   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92961   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92962
92963   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92964   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92965   {
92966     try {
92967       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92968     } catch (std::out_of_range& e) {
92969       {
92970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92971       };
92972     } catch (std::exception& e) {
92973       {
92974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92975       };
92976     } catch (Dali::DaliException e) {
92977       {
92978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92979       };
92980     } catch (...) {
92981       {
92982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92983       };
92984     }
92985   }
92986
92987 }
92988
92989
92990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92991   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92992   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92993
92994   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92995   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92996   {
92997     try {
92998       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92999     } catch (std::out_of_range& e) {
93000       {
93001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93002       };
93003     } catch (std::exception& e) {
93004       {
93005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93006       };
93007     } catch (Dali::DaliException e) {
93008       {
93009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93010       };
93011     } catch (...) {
93012       {
93013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93014       };
93015     }
93016   }
93017
93018 }
93019
93020
93021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
93022   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
93023   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
93024
93025   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
93026   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
93027   if (!arg2) {
93028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
93029     return ;
93030   }
93031   {
93032     try {
93033       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
93034     } catch (std::out_of_range& e) {
93035       {
93036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93037       };
93038     } catch (std::exception& e) {
93039       {
93040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93041       };
93042     } catch (Dali::DaliException e) {
93043       {
93044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93045       };
93046     } catch (...) {
93047       {
93048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93049       };
93050     }
93051   }
93052
93053 }
93054
93055
93056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
93057   void * jresult ;
93058   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
93059
93060   {
93061     try {
93062       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
93063     } catch (std::out_of_range& e) {
93064       {
93065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93066       };
93067     } catch (std::exception& e) {
93068       {
93069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93070       };
93071     } catch (Dali::DaliException e) {
93072       {
93073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93074       };
93075     } catch (...) {
93076       {
93077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93078       };
93079     }
93080   }
93081
93082   jresult = (void *)result;
93083   return jresult;
93084 }
93085
93086
93087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
93088   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
93089
93090   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
93091   {
93092     try {
93093       delete arg1;
93094     } catch (std::out_of_range& e) {
93095       {
93096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93097       };
93098     } catch (std::exception& e) {
93099       {
93100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93101       };
93102     } catch (Dali::DaliException e) {
93103       {
93104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93105       };
93106     } catch (...) {
93107       {
93108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93109       };
93110     }
93111   }
93112
93113 }
93114
93115
93116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
93117   unsigned int jresult ;
93118   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
93119   bool result;
93120
93121   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
93122   {
93123     try {
93124       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
93125     } catch (std::out_of_range& e) {
93126       {
93127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93128       };
93129     } catch (std::exception& e) {
93130       {
93131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93132       };
93133     } catch (Dali::DaliException e) {
93134       {
93135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93136       };
93137     } catch (...) {
93138       {
93139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93140       };
93141     }
93142   }
93143
93144   jresult = result;
93145   return jresult;
93146 }
93147
93148
93149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
93150   unsigned long jresult ;
93151   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
93152   std::size_t result;
93153
93154   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
93155   {
93156     try {
93157       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
93158     } catch (std::out_of_range& e) {
93159       {
93160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93161       };
93162     } catch (std::exception& e) {
93163       {
93164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93165       };
93166     } catch (Dali::DaliException e) {
93167       {
93168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93169       };
93170     } catch (...) {
93171       {
93172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93173       };
93174     }
93175   }
93176
93177   jresult = (unsigned long)result;
93178   return jresult;
93179 }
93180
93181
93182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
93183   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
93184   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
93185
93186   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
93187   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
93188   {
93189     try {
93190       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
93191     } catch (std::out_of_range& e) {
93192       {
93193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93194       };
93195     } catch (std::exception& e) {
93196       {
93197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93198       };
93199     } catch (Dali::DaliException e) {
93200       {
93201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93202       };
93203     } catch (...) {
93204       {
93205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93206       };
93207     }
93208   }
93209
93210 }
93211
93212
93213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
93214   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
93215   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
93216
93217   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
93218   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
93219   {
93220     try {
93221       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
93222     } catch (std::out_of_range& e) {
93223       {
93224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93225       };
93226     } catch (std::exception& e) {
93227       {
93228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93229       };
93230     } catch (Dali::DaliException e) {
93231       {
93232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93233       };
93234     } catch (...) {
93235       {
93236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93237       };
93238     }
93239   }
93240
93241 }
93242
93243
93244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
93245   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
93246   Dali::Vector2 *arg2 = 0 ;
93247
93248   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
93249   arg2 = (Dali::Vector2 *)jarg2;
93250   if (!arg2) {
93251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
93252     return ;
93253   }
93254   {
93255     try {
93256       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
93257     } catch (std::out_of_range& e) {
93258       {
93259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93260       };
93261     } catch (std::exception& e) {
93262       {
93263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93264       };
93265     } catch (Dali::DaliException e) {
93266       {
93267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93268       };
93269     } catch (...) {
93270       {
93271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93272       };
93273     }
93274   }
93275
93276 }
93277
93278
93279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
93280   void * jresult ;
93281   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
93282
93283   {
93284     try {
93285       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
93286     } catch (std::out_of_range& e) {
93287       {
93288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93289       };
93290     } catch (std::exception& e) {
93291       {
93292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93293       };
93294     } catch (Dali::DaliException e) {
93295       {
93296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93297       };
93298     } catch (...) {
93299       {
93300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93301       };
93302     }
93303   }
93304
93305   jresult = (void *)result;
93306   return jresult;
93307 }
93308
93309
93310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
93311   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
93312
93313   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
93314   {
93315     try {
93316       delete arg1;
93317     } catch (std::out_of_range& e) {
93318       {
93319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93320       };
93321     } catch (std::exception& e) {
93322       {
93323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93324       };
93325     } catch (Dali::DaliException e) {
93326       {
93327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93328       };
93329     } catch (...) {
93330       {
93331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93332       };
93333     }
93334   }
93335
93336 }
93337
93338
93339
93340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
93341   unsigned int jresult ;
93342   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93343   bool result;
93344
93345   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93346   {
93347     try {
93348       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);
93349     } catch (std::out_of_range& e) {
93350       {
93351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93352       };
93353     } catch (std::exception& e) {
93354       {
93355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93356       };
93357     } catch (Dali::DaliException e) {
93358       {
93359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93360       };
93361     } catch (...) {
93362       {
93363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93364       };
93365     }
93366   }
93367
93368   jresult = result;
93369   return jresult;
93370 }
93371
93372
93373 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
93374   unsigned long jresult ;
93375   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93376   std::size_t result;
93377
93378   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93379   {
93380     try {
93381       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);
93382     } catch (std::out_of_range& e) {
93383       {
93384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93385       };
93386     } catch (std::exception& e) {
93387       {
93388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93389       };
93390     } catch (Dali::DaliException e) {
93391       {
93392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93393       };
93394     } catch (...) {
93395       {
93396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93397       };
93398     }
93399   }
93400
93401   jresult = (unsigned long)result;
93402   return jresult;
93403 }
93404
93405
93406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
93407   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93408   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
93409
93410   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93411   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
93412   {
93413     try {
93414       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
93415     } catch (std::out_of_range& e) {
93416       {
93417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93418       };
93419     } catch (std::exception& e) {
93420       {
93421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93422       };
93423     } catch (Dali::DaliException e) {
93424       {
93425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93426       };
93427     } catch (...) {
93428       {
93429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93430       };
93431     }
93432   }
93433
93434 }
93435
93436
93437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
93438   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93439   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
93440
93441   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93442   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
93443   {
93444     try {
93445       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
93446     } catch (std::out_of_range& e) {
93447       {
93448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93449       };
93450     } catch (std::exception& e) {
93451       {
93452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93453       };
93454     } catch (Dali::DaliException e) {
93455       {
93456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93457       };
93458     } catch (...) {
93459       {
93460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93461       };
93462     }
93463   }
93464
93465 }
93466
93467
93468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
93469   unsigned int jresult ;
93470   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93471   Dali::Toolkit::Control arg2 ;
93472   Dali::KeyEvent *arg3 = 0 ;
93473   Dali::Toolkit::Control *argp2 ;
93474   bool result;
93475
93476   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93477   argp2 = (Dali::Toolkit::Control *)jarg2;
93478   if (!argp2) {
93479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93480     return 0;
93481   }
93482   arg2 = *argp2;
93483   arg3 = (Dali::KeyEvent *)jarg3;
93484   if (!arg3) {
93485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
93486     return 0;
93487   }
93488   {
93489     try {
93490       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);
93491     } catch (std::out_of_range& e) {
93492       {
93493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93494       };
93495     } catch (std::exception& e) {
93496       {
93497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93498       };
93499     } catch (Dali::DaliException e) {
93500       {
93501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93502       };
93503     } catch (...) {
93504       {
93505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93506       };
93507     }
93508   }
93509
93510   jresult = result;
93511   return jresult;
93512 }
93513
93514
93515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
93516   void * jresult ;
93517   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
93518
93519   {
93520     try {
93521       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
93522     } catch (std::out_of_range& e) {
93523       {
93524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93525       };
93526     } catch (std::exception& e) {
93527       {
93528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93529       };
93530     } catch (Dali::DaliException e) {
93531       {
93532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93533       };
93534     } catch (...) {
93535       {
93536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93537       };
93538     }
93539   }
93540
93541   jresult = (void *)result;
93542   return jresult;
93543 }
93544
93545
93546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
93547   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93548
93549   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93550   {
93551     try {
93552       delete arg1;
93553     } catch (std::out_of_range& e) {
93554       {
93555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93556       };
93557     } catch (std::exception& e) {
93558       {
93559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93560       };
93561     } catch (Dali::DaliException e) {
93562       {
93563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93564       };
93565     } catch (...) {
93566       {
93567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93568       };
93569     }
93570   }
93571
93572 }
93573
93574
93575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
93576   unsigned int jresult ;
93577   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93578   bool result;
93579
93580   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93581   {
93582     try {
93583       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93584     } catch (std::out_of_range& e) {
93585       {
93586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93587       };
93588     } catch (std::exception& e) {
93589       {
93590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93591       };
93592     } catch (Dali::DaliException e) {
93593       {
93594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93595       };
93596     } catch (...) {
93597       {
93598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93599       };
93600     }
93601   }
93602
93603   jresult = result;
93604   return jresult;
93605 }
93606
93607
93608 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
93609   unsigned long jresult ;
93610   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93611   std::size_t result;
93612
93613   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93614   {
93615     try {
93616       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93617     } catch (std::out_of_range& e) {
93618       {
93619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93620       };
93621     } catch (std::exception& e) {
93622       {
93623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93624       };
93625     } catch (Dali::DaliException e) {
93626       {
93627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93628       };
93629     } catch (...) {
93630       {
93631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93632       };
93633     }
93634   }
93635
93636   jresult = (unsigned long)result;
93637   return jresult;
93638 }
93639
93640
93641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
93642   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93643   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93644
93645   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93646   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93647   {
93648     try {
93649       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93650     } catch (std::out_of_range& e) {
93651       {
93652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93653       };
93654     } catch (std::exception& e) {
93655       {
93656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93657       };
93658     } catch (Dali::DaliException e) {
93659       {
93660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93661       };
93662     } catch (...) {
93663       {
93664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93665       };
93666     }
93667   }
93668
93669 }
93670
93671
93672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93673   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93674   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93675
93676   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93677   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93678   {
93679     try {
93680       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93681     } catch (std::out_of_range& e) {
93682       {
93683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93684       };
93685     } catch (std::exception& e) {
93686       {
93687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93688       };
93689     } catch (Dali::DaliException e) {
93690       {
93691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93692       };
93693     } catch (...) {
93694       {
93695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93696       };
93697     }
93698   }
93699
93700 }
93701
93702
93703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93704   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93705   Dali::Toolkit::Control arg2 ;
93706   Dali::Toolkit::Control *argp2 ;
93707
93708   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93709   argp2 = (Dali::Toolkit::Control *)jarg2;
93710   if (!argp2) {
93711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93712     return ;
93713   }
93714   arg2 = *argp2;
93715   {
93716     try {
93717       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93718     } catch (std::out_of_range& e) {
93719       {
93720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93721       };
93722     } catch (std::exception& e) {
93723       {
93724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93725       };
93726     } catch (Dali::DaliException e) {
93727       {
93728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93729       };
93730     } catch (...) {
93731       {
93732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93733       };
93734     }
93735   }
93736
93737 }
93738
93739
93740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93741   void * jresult ;
93742   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93743
93744   {
93745     try {
93746       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93747     } catch (std::out_of_range& e) {
93748       {
93749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93750       };
93751     } catch (std::exception& e) {
93752       {
93753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93754       };
93755     } catch (Dali::DaliException e) {
93756       {
93757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93758       };
93759     } catch (...) {
93760       {
93761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93762       };
93763     }
93764   }
93765
93766   jresult = (void *)result;
93767   return jresult;
93768 }
93769
93770
93771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93772   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93773
93774   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93775   {
93776     try {
93777       delete arg1;
93778     } catch (std::out_of_range& e) {
93779       {
93780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93781       };
93782     } catch (std::exception& e) {
93783       {
93784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93785       };
93786     } catch (Dali::DaliException e) {
93787       {
93788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93789       };
93790     } catch (...) {
93791       {
93792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93793       };
93794     }
93795   }
93796
93797 }
93798
93799
93800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93801   unsigned int jresult ;
93802   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93803   bool result;
93804
93805   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93806   {
93807     try {
93808       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93809     } catch (std::out_of_range& e) {
93810       {
93811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93812       };
93813     } catch (std::exception& e) {
93814       {
93815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93816       };
93817     } catch (Dali::DaliException e) {
93818       {
93819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93820       };
93821     } catch (...) {
93822       {
93823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93824       };
93825     }
93826   }
93827
93828   jresult = result;
93829   return jresult;
93830 }
93831
93832
93833 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93834   unsigned long jresult ;
93835   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93836   std::size_t result;
93837
93838   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93839   {
93840     try {
93841       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93842     } catch (std::out_of_range& e) {
93843       {
93844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93845       };
93846     } catch (std::exception& e) {
93847       {
93848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93849       };
93850     } catch (Dali::DaliException e) {
93851       {
93852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93853       };
93854     } catch (...) {
93855       {
93856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93857       };
93858     }
93859   }
93860
93861   jresult = (unsigned long)result;
93862   return jresult;
93863 }
93864
93865
93866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93867   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93868   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93869
93870   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93871   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93872   {
93873     try {
93874       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93875     } catch (std::out_of_range& e) {
93876       {
93877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93878       };
93879     } catch (std::exception& e) {
93880       {
93881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93882       };
93883     } catch (Dali::DaliException e) {
93884       {
93885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93886       };
93887     } catch (...) {
93888       {
93889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93890       };
93891     }
93892   }
93893
93894 }
93895
93896
93897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93898   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93899   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93900
93901   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93902   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93903   {
93904     try {
93905       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93906     } catch (std::out_of_range& e) {
93907       {
93908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93909       };
93910     } catch (std::exception& e) {
93911       {
93912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93913       };
93914     } catch (Dali::DaliException e) {
93915       {
93916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93917       };
93918     } catch (...) {
93919       {
93920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93921       };
93922     }
93923   }
93924
93925 }
93926
93927
93928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93929   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93930   Dali::Toolkit::VideoView *arg2 = 0 ;
93931
93932   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93933   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93934   if (!arg2) {
93935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93936     return ;
93937   }
93938   {
93939     try {
93940       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93941     } catch (std::out_of_range& e) {
93942       {
93943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93944       };
93945     } catch (std::exception& e) {
93946       {
93947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93948       };
93949     } catch (Dali::DaliException e) {
93950       {
93951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93952       };
93953     } catch (...) {
93954       {
93955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93956       };
93957     }
93958   }
93959
93960 }
93961
93962
93963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93964   void * jresult ;
93965   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93966
93967   {
93968     try {
93969       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93970     } catch (std::out_of_range& e) {
93971       {
93972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93973       };
93974     } catch (std::exception& e) {
93975       {
93976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93977       };
93978     } catch (Dali::DaliException e) {
93979       {
93980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93981       };
93982     } catch (...) {
93983       {
93984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93985       };
93986     }
93987   }
93988
93989   jresult = (void *)result;
93990   return jresult;
93991 }
93992
93993
93994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93995   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93996
93997   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93998   {
93999     try {
94000       delete arg1;
94001     } catch (std::out_of_range& e) {
94002       {
94003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94004       };
94005     } catch (std::exception& e) {
94006       {
94007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94008       };
94009     } catch (Dali::DaliException e) {
94010       {
94011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94012       };
94013     } catch (...) {
94014       {
94015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94016       };
94017     }
94018   }
94019
94020 }
94021
94022
94023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
94024   unsigned int jresult ;
94025   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
94026   bool result;
94027
94028   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
94029   {
94030     try {
94031       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
94032     } catch (std::out_of_range& e) {
94033       {
94034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94035       };
94036     } catch (std::exception& e) {
94037       {
94038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94039       };
94040     } catch (Dali::DaliException e) {
94041       {
94042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94043       };
94044     } catch (...) {
94045       {
94046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94047       };
94048     }
94049   }
94050
94051   jresult = result;
94052   return jresult;
94053 }
94054
94055
94056 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
94057   unsigned long jresult ;
94058   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
94059   std::size_t result;
94060
94061   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
94062   {
94063     try {
94064       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
94065     } catch (std::out_of_range& e) {
94066       {
94067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94068       };
94069     } catch (std::exception& e) {
94070       {
94071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94072       };
94073     } catch (Dali::DaliException e) {
94074       {
94075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94076       };
94077     } catch (...) {
94078       {
94079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94080       };
94081     }
94082   }
94083
94084   jresult = (unsigned long)result;
94085   return jresult;
94086 }
94087
94088
94089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
94090   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
94091   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
94092
94093   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
94094   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
94095   {
94096     try {
94097       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
94098     } catch (std::out_of_range& e) {
94099       {
94100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94101       };
94102     } catch (std::exception& e) {
94103       {
94104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94105       };
94106     } catch (Dali::DaliException e) {
94107       {
94108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94109       };
94110     } catch (...) {
94111       {
94112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94113       };
94114     }
94115   }
94116
94117 }
94118
94119
94120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94121   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
94122   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
94123
94124   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
94125   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
94126   {
94127     try {
94128       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
94129     } catch (std::out_of_range& e) {
94130       {
94131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94132       };
94133     } catch (std::exception& e) {
94134       {
94135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94136       };
94137     } catch (Dali::DaliException e) {
94138       {
94139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94140       };
94141     } catch (...) {
94142       {
94143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94144       };
94145     }
94146   }
94147
94148 }
94149
94150
94151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
94152   unsigned int jresult ;
94153   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
94154   Dali::Toolkit::Slider arg2 ;
94155   float arg3 ;
94156   Dali::Toolkit::Slider *argp2 ;
94157   bool result;
94158
94159   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
94160   argp2 = (Dali::Toolkit::Slider *)jarg2;
94161   if (!argp2) {
94162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
94163     return 0;
94164   }
94165   arg2 = *argp2;
94166   arg3 = (float)jarg3;
94167   {
94168     try {
94169       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
94170     } catch (std::out_of_range& e) {
94171       {
94172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94173       };
94174     } catch (std::exception& e) {
94175       {
94176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94177       };
94178     } catch (Dali::DaliException e) {
94179       {
94180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94181       };
94182     } catch (...) {
94183       {
94184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94185       };
94186     }
94187   }
94188
94189   jresult = result;
94190   return jresult;
94191 }
94192
94193
94194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
94195   void * jresult ;
94196   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
94197
94198   {
94199     try {
94200       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
94201     } catch (std::out_of_range& e) {
94202       {
94203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94204       };
94205     } catch (std::exception& e) {
94206       {
94207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94208       };
94209     } catch (Dali::DaliException e) {
94210       {
94211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94212       };
94213     } catch (...) {
94214       {
94215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94216       };
94217     }
94218   }
94219
94220   jresult = (void *)result;
94221   return jresult;
94222 }
94223
94224
94225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
94226   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
94227
94228   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
94229   {
94230     try {
94231       delete arg1;
94232     } catch (std::out_of_range& e) {
94233       {
94234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94235       };
94236     } catch (std::exception& e) {
94237       {
94238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94239       };
94240     } catch (Dali::DaliException e) {
94241       {
94242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94243       };
94244     } catch (...) {
94245       {
94246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94247       };
94248     }
94249   }
94250
94251 }
94252
94253
94254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
94255   unsigned int jresult ;
94256   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94257   bool result;
94258
94259   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94260   {
94261     try {
94262       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
94263     } catch (std::out_of_range& e) {
94264       {
94265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94266       };
94267     } catch (std::exception& e) {
94268       {
94269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94270       };
94271     } catch (Dali::DaliException e) {
94272       {
94273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94274       };
94275     } catch (...) {
94276       {
94277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94278       };
94279     }
94280   }
94281
94282   jresult = result;
94283   return jresult;
94284 }
94285
94286
94287 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
94288   unsigned long jresult ;
94289   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94290   std::size_t result;
94291
94292   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94293   {
94294     try {
94295       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
94296     } catch (std::out_of_range& e) {
94297       {
94298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94299       };
94300     } catch (std::exception& e) {
94301       {
94302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94303       };
94304     } catch (Dali::DaliException e) {
94305       {
94306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94307       };
94308     } catch (...) {
94309       {
94310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94311       };
94312     }
94313   }
94314
94315   jresult = (unsigned long)result;
94316   return jresult;
94317 }
94318
94319
94320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
94321   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94322   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
94323
94324   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94325   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
94326   {
94327     try {
94328       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
94329     } catch (std::out_of_range& e) {
94330       {
94331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94332       };
94333     } catch (std::exception& e) {
94334       {
94335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94336       };
94337     } catch (Dali::DaliException e) {
94338       {
94339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94340       };
94341     } catch (...) {
94342       {
94343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94344       };
94345     }
94346   }
94347
94348 }
94349
94350
94351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
94352   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94353   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
94354
94355   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94356   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
94357   {
94358     try {
94359       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
94360     } catch (std::out_of_range& e) {
94361       {
94362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94363       };
94364     } catch (std::exception& e) {
94365       {
94366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94367       };
94368     } catch (Dali::DaliException e) {
94369       {
94370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94371       };
94372     } catch (...) {
94373       {
94374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94375       };
94376     }
94377   }
94378
94379 }
94380
94381
94382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94383   unsigned int jresult ;
94384   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94385   Dali::Toolkit::Slider arg2 ;
94386   int arg3 ;
94387   Dali::Toolkit::Slider *argp2 ;
94388   bool result;
94389
94390   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94391   argp2 = (Dali::Toolkit::Slider *)jarg2;
94392   if (!argp2) {
94393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
94394     return 0;
94395   }
94396   arg2 = *argp2;
94397   arg3 = (int)jarg3;
94398   {
94399     try {
94400       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
94401     } catch (std::out_of_range& e) {
94402       {
94403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94404       };
94405     } catch (std::exception& e) {
94406       {
94407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94408       };
94409     } catch (Dali::DaliException e) {
94410       {
94411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94412       };
94413     } catch (...) {
94414       {
94415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94416       };
94417     }
94418   }
94419
94420   jresult = result;
94421   return jresult;
94422 }
94423
94424
94425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
94426   void * jresult ;
94427   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
94428
94429   {
94430     try {
94431       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
94432     } catch (std::out_of_range& e) {
94433       {
94434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94435       };
94436     } catch (std::exception& e) {
94437       {
94438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94439       };
94440     } catch (Dali::DaliException e) {
94441       {
94442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94443       };
94444     } catch (...) {
94445       {
94446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94447       };
94448     }
94449   }
94450
94451   jresult = (void *)result;
94452   return jresult;
94453 }
94454
94455
94456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
94457   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94458
94459   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94460   {
94461     try {
94462       delete arg1;
94463     } catch (std::out_of_range& e) {
94464       {
94465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94466       };
94467     } catch (std::exception& e) {
94468       {
94469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94470       };
94471     } catch (Dali::DaliException e) {
94472       {
94473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94474       };
94475     } catch (...) {
94476       {
94477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94478       };
94479     }
94480   }
94481
94482 }
94483
94484
94485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
94486   void * jresult ;
94487   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94488
94489   {
94490     try {
94491       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
94492     } catch (std::out_of_range& e) {
94493       {
94494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94495       };
94496     } catch (std::exception& e) {
94497       {
94498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94499       };
94500     } catch (Dali::DaliException e) {
94501       {
94502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94503       };
94504     } catch (...) {
94505       {
94506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94507       };
94508     }
94509   }
94510
94511   jresult = (void *)result;
94512   return jresult;
94513 }
94514
94515
94516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
94517   void * jresult ;
94518   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
94519   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94520
94521   arg1 = (Dali::Toolkit::Ruler *)jarg1;
94522   {
94523     try {
94524       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
94525     } catch (std::out_of_range& e) {
94526       {
94527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94528       };
94529     } catch (std::exception& e) {
94530       {
94531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94532       };
94533     } catch (Dali::DaliException e) {
94534       {
94535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94536       };
94537     } catch (...) {
94538       {
94539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94540       };
94541     }
94542   }
94543
94544   jresult = (void *)result;
94545   return jresult;
94546 }
94547
94548
94549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
94550   void * jresult ;
94551   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
94552   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94553
94554   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94555   if (!arg1) {
94556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94557     return 0;
94558   }
94559   {
94560     try {
94561       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
94562     } catch (std::out_of_range& e) {
94563       {
94564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94565       };
94566     } catch (std::exception& e) {
94567       {
94568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94569       };
94570     } catch (Dali::DaliException e) {
94571       {
94572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94573       };
94574     } catch (...) {
94575       {
94576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94577       };
94578     }
94579   }
94580
94581   jresult = (void *)result;
94582   return jresult;
94583 }
94584
94585
94586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
94587   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94588
94589   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94590   {
94591     try {
94592       delete arg1;
94593     } catch (std::out_of_range& e) {
94594       {
94595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94596       };
94597     } catch (std::exception& e) {
94598       {
94599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94600       };
94601     } catch (Dali::DaliException e) {
94602       {
94603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94604       };
94605     } catch (...) {
94606       {
94607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94608       };
94609     }
94610   }
94611
94612 }
94613
94614
94615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
94616   void * jresult ;
94617   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94618   Dali::Toolkit::Ruler *result = 0 ;
94619
94620   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94621   {
94622     try {
94623       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
94624     } catch (std::out_of_range& e) {
94625       {
94626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94627       };
94628     } catch (std::exception& e) {
94629       {
94630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94631       };
94632     } catch (Dali::DaliException e) {
94633       {
94634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94635       };
94636     } catch (...) {
94637       {
94638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94639       };
94640     }
94641   }
94642
94643   jresult = (void *)result;
94644   return jresult;
94645 }
94646
94647
94648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
94649   void * jresult ;
94650   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94651   Dali::Toolkit::Ruler *result = 0 ;
94652
94653   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94654   {
94655     try {
94656       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
94657     } catch (std::out_of_range& e) {
94658       {
94659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94660       };
94661     } catch (std::exception& e) {
94662       {
94663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94664       };
94665     } catch (Dali::DaliException e) {
94666       {
94667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94668       };
94669     } catch (...) {
94670       {
94671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94672       };
94673     }
94674   }
94675
94676   jresult = (void *)result;
94677   return jresult;
94678 }
94679
94680
94681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94682   void * jresult ;
94683   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94684   Dali::Toolkit::Ruler *result = 0 ;
94685
94686   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94687   {
94688     try {
94689       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94690     } catch (std::out_of_range& e) {
94691       {
94692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94693       };
94694     } catch (std::exception& e) {
94695       {
94696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94697       };
94698     } catch (Dali::DaliException e) {
94699       {
94700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94701       };
94702     } catch (...) {
94703       {
94704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94705       };
94706     }
94707   }
94708
94709   jresult = (void *)result;
94710   return jresult;
94711 }
94712
94713
94714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94715   void * jresult ;
94716   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94717   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94718   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94719
94720   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94721   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94722   if (!arg2) {
94723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94724     return 0;
94725   }
94726   {
94727     try {
94728       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94729     } catch (std::out_of_range& e) {
94730       {
94731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94732       };
94733     } catch (std::exception& e) {
94734       {
94735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94736       };
94737     } catch (Dali::DaliException e) {
94738       {
94739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94740       };
94741     } catch (...) {
94742       {
94743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94744       };
94745     }
94746   }
94747
94748   jresult = (void *)result;
94749   return jresult;
94750 }
94751
94752
94753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94754   void * jresult ;
94755   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94756   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94757   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94758
94759   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94760   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94761   {
94762     try {
94763       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94764     } catch (std::out_of_range& e) {
94765       {
94766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94767       };
94768     } catch (std::exception& e) {
94769       {
94770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94771       };
94772     } catch (Dali::DaliException e) {
94773       {
94774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94775       };
94776     } catch (...) {
94777       {
94778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94779       };
94780     }
94781   }
94782
94783   jresult = (void *)result;
94784   return jresult;
94785 }
94786
94787
94788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94789   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94790
94791   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94792   {
94793     try {
94794       (arg1)->Reset();
94795     } catch (std::out_of_range& e) {
94796       {
94797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94798       };
94799     } catch (std::exception& e) {
94800       {
94801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94802       };
94803     } catch (Dali::DaliException e) {
94804       {
94805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94806       };
94807     } catch (...) {
94808       {
94809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94810       };
94811     }
94812   }
94813
94814 }
94815
94816
94817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94818   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94819   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94820
94821   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94822   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94823   {
94824     try {
94825       (arg1)->Reset(arg2);
94826     } catch (std::out_of_range& e) {
94827       {
94828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94829       };
94830     } catch (std::exception& e) {
94831       {
94832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94833       };
94834     } catch (Dali::DaliException e) {
94835       {
94836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94837       };
94838     } catch (...) {
94839       {
94840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94841       };
94842     }
94843   }
94844
94845 }
94846
94847
94848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94849   void * jresult ;
94850   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94851   Dali::Toolkit::Ruler *result = 0 ;
94852
94853   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94854   {
94855     try {
94856       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94857     } catch (std::out_of_range& e) {
94858       {
94859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94860       };
94861     } catch (std::exception& e) {
94862       {
94863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94864       };
94865     } catch (Dali::DaliException e) {
94866       {
94867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94868       };
94869     } catch (...) {
94870       {
94871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94872       };
94873     }
94874   }
94875
94876   jresult = (void *)result;
94877   return jresult;
94878 }
94879
94880
94881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94882   float jresult ;
94883   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94884   float arg2 ;
94885   float arg3 ;
94886   float result;
94887
94888   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94889   arg2 = (float)jarg2;
94890   arg3 = (float)jarg3;
94891   {
94892     try {
94893       result = (float)(*arg1)->Snap(arg2,arg3);
94894     } catch (std::out_of_range& e) {
94895       {
94896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94897       };
94898     } catch (std::exception& e) {
94899       {
94900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94901       };
94902     } catch (Dali::DaliException e) {
94903       {
94904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94905       };
94906     } catch (...) {
94907       {
94908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94909       };
94910     }
94911   }
94912
94913   jresult = result;
94914   return jresult;
94915 }
94916
94917
94918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94919   float jresult ;
94920   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94921   float arg2 ;
94922   float result;
94923
94924   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94925   arg2 = (float)jarg2;
94926   {
94927     try {
94928       result = (float)(*arg1)->Snap(arg2);
94929     } catch (std::out_of_range& e) {
94930       {
94931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94932       };
94933     } catch (std::exception& e) {
94934       {
94935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94936       };
94937     } catch (Dali::DaliException e) {
94938       {
94939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94940       };
94941     } catch (...) {
94942       {
94943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94944       };
94945     }
94946   }
94947
94948   jresult = result;
94949   return jresult;
94950 }
94951
94952
94953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94954   float jresult ;
94955   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94956   unsigned int arg2 ;
94957   unsigned int *arg3 = 0 ;
94958   bool arg4 ;
94959   float result;
94960
94961   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94962   arg2 = (unsigned int)jarg2;
94963   arg3 = (unsigned int *)jarg3;
94964   arg4 = jarg4 ? true : false;
94965   {
94966     try {
94967       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94968     } catch (std::out_of_range& e) {
94969       {
94970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94971       };
94972     } catch (std::exception& e) {
94973       {
94974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94975       };
94976     } catch (Dali::DaliException e) {
94977       {
94978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94979       };
94980     } catch (...) {
94981       {
94982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94983       };
94984     }
94985   }
94986
94987   jresult = result;
94988   return jresult;
94989 }
94990
94991
94992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94993   unsigned int jresult ;
94994   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94995   float arg2 ;
94996   bool arg3 ;
94997   unsigned int result;
94998
94999   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95000   arg2 = (float)jarg2;
95001   arg3 = jarg3 ? true : false;
95002   {
95003     try {
95004       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
95005     } catch (std::out_of_range& e) {
95006       {
95007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95008       };
95009     } catch (std::exception& e) {
95010       {
95011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95012       };
95013     } catch (Dali::DaliException e) {
95014       {
95015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95016       };
95017     } catch (...) {
95018       {
95019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95020       };
95021     }
95022   }
95023
95024   jresult = result;
95025   return jresult;
95026 }
95027
95028
95029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
95030   unsigned int jresult ;
95031   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95032   unsigned int result;
95033
95034   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95035   {
95036     try {
95037       result = (unsigned int)(*arg1)->GetTotalPages();
95038     } catch (std::out_of_range& e) {
95039       {
95040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95041       };
95042     } catch (std::exception& e) {
95043       {
95044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95045       };
95046     } catch (Dali::DaliException e) {
95047       {
95048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95049       };
95050     } catch (...) {
95051       {
95052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95053       };
95054     }
95055   }
95056
95057   jresult = result;
95058   return jresult;
95059 }
95060
95061
95062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
95063   int jresult ;
95064   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95065   Dali::Toolkit::Ruler::RulerType result;
95066
95067   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95068   {
95069     try {
95070       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
95071     } catch (std::out_of_range& e) {
95072       {
95073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95074       };
95075     } catch (std::exception& e) {
95076       {
95077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95078       };
95079     } catch (Dali::DaliException e) {
95080       {
95081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95082       };
95083     } catch (...) {
95084       {
95085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95086       };
95087     }
95088   }
95089
95090   jresult = (int)result;
95091   return jresult;
95092 }
95093
95094
95095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
95096   unsigned int jresult ;
95097   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95098   bool result;
95099
95100   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95101   {
95102     try {
95103       result = (bool)(*arg1)->IsEnabled();
95104     } catch (std::out_of_range& e) {
95105       {
95106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95107       };
95108     } catch (std::exception& e) {
95109       {
95110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95111       };
95112     } catch (Dali::DaliException e) {
95113       {
95114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95115       };
95116     } catch (...) {
95117       {
95118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95119       };
95120     }
95121   }
95122
95123   jresult = result;
95124   return jresult;
95125 }
95126
95127
95128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
95129   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95130
95131   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95132   {
95133     try {
95134       (*arg1)->Enable();
95135     } catch (std::out_of_range& e) {
95136       {
95137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95138       };
95139     } catch (std::exception& e) {
95140       {
95141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95142       };
95143     } catch (Dali::DaliException e) {
95144       {
95145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95146       };
95147     } catch (...) {
95148       {
95149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95150       };
95151     }
95152   }
95153
95154 }
95155
95156
95157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
95158   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95159
95160   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95161   {
95162     try {
95163       (*arg1)->Disable();
95164     } catch (std::out_of_range& e) {
95165       {
95166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95167       };
95168     } catch (std::exception& e) {
95169       {
95170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95171       };
95172     } catch (Dali::DaliException e) {
95173       {
95174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95175       };
95176     } catch (...) {
95177       {
95178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95179       };
95180     }
95181   }
95182
95183 }
95184
95185
95186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
95187   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95188   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
95189   Dali::Toolkit::RulerDomain *argp2 ;
95190
95191   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95192   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
95193   if (!argp2) {
95194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
95195     return ;
95196   }
95197   arg2 = *argp2;
95198   {
95199     try {
95200       (*arg1)->SetDomain(arg2);
95201     } catch (std::out_of_range& e) {
95202       {
95203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95204       };
95205     } catch (std::exception& e) {
95206       {
95207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95208       };
95209     } catch (Dali::DaliException e) {
95210       {
95211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95212       };
95213     } catch (...) {
95214       {
95215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95216       };
95217     }
95218   }
95219
95220 }
95221
95222
95223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
95224   void * jresult ;
95225   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95226   Dali::Toolkit::RulerDomain *result = 0 ;
95227
95228   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95229   {
95230     try {
95231       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
95232     } catch (std::out_of_range& e) {
95233       {
95234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95235       };
95236     } catch (std::exception& e) {
95237       {
95238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95239       };
95240     } catch (Dali::DaliException e) {
95241       {
95242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95243       };
95244     } catch (...) {
95245       {
95246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95247       };
95248     }
95249   }
95250
95251   jresult = (void *)result;
95252   return jresult;
95253 }
95254
95255
95256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
95257   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95258
95259   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95260   {
95261     try {
95262       (*arg1)->DisableDomain();
95263     } catch (std::out_of_range& e) {
95264       {
95265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95266       };
95267     } catch (std::exception& e) {
95268       {
95269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95270       };
95271     } catch (Dali::DaliException e) {
95272       {
95273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95274       };
95275     } catch (...) {
95276       {
95277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95278       };
95279     }
95280   }
95281
95282 }
95283
95284
95285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
95286   float jresult ;
95287   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95288   float arg2 ;
95289   float arg3 ;
95290   float arg4 ;
95291   float result;
95292
95293   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95294   arg2 = (float)jarg2;
95295   arg3 = (float)jarg3;
95296   arg4 = (float)jarg4;
95297   {
95298     try {
95299       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
95300     } catch (std::out_of_range& e) {
95301       {
95302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95303       };
95304     } catch (std::exception& e) {
95305       {
95306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95307       };
95308     } catch (Dali::DaliException e) {
95309       {
95310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95311       };
95312     } catch (...) {
95313       {
95314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95315       };
95316     }
95317   }
95318
95319   jresult = result;
95320   return jresult;
95321 }
95322
95323
95324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
95325   float jresult ;
95326   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95327   float arg2 ;
95328   float arg3 ;
95329   float result;
95330
95331   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95332   arg2 = (float)jarg2;
95333   arg3 = (float)jarg3;
95334   {
95335     try {
95336       result = (float)(*arg1)->Clamp(arg2,arg3);
95337     } catch (std::out_of_range& e) {
95338       {
95339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95340       };
95341     } catch (std::exception& e) {
95342       {
95343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95344       };
95345     } catch (Dali::DaliException e) {
95346       {
95347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95348       };
95349     } catch (...) {
95350       {
95351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95352       };
95353     }
95354   }
95355
95356   jresult = result;
95357   return jresult;
95358 }
95359
95360
95361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
95362   float jresult ;
95363   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95364   float arg2 ;
95365   float result;
95366
95367   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95368   arg2 = (float)jarg2;
95369   {
95370     try {
95371       result = (float)(*arg1)->Clamp(arg2);
95372     } catch (std::out_of_range& e) {
95373       {
95374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95375       };
95376     } catch (std::exception& e) {
95377       {
95378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95379       };
95380     } catch (Dali::DaliException e) {
95381       {
95382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95383       };
95384     } catch (...) {
95385       {
95386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95387       };
95388     }
95389   }
95390
95391   jresult = result;
95392   return jresult;
95393 }
95394
95395
95396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
95397   float jresult ;
95398   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95399   float arg2 ;
95400   float arg3 ;
95401   float arg4 ;
95402   Dali::Toolkit::ClampState *arg5 = 0 ;
95403   float result;
95404
95405   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95406   arg2 = (float)jarg2;
95407   arg3 = (float)jarg3;
95408   arg4 = (float)jarg4;
95409   arg5 = (Dali::Toolkit::ClampState *)jarg5;
95410   if (!arg5) {
95411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95412     return 0;
95413   }
95414   {
95415     try {
95416       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
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 = result;
95437   return jresult;
95438 }
95439
95440
95441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
95442   float jresult ;
95443   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95444   float arg2 ;
95445   float arg3 ;
95446   float arg4 ;
95447   float arg5 ;
95448   float result;
95449
95450   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95451   arg2 = (float)jarg2;
95452   arg3 = (float)jarg3;
95453   arg4 = (float)jarg4;
95454   arg5 = (float)jarg5;
95455   {
95456     try {
95457       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
95458     } catch (std::out_of_range& e) {
95459       {
95460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95461       };
95462     } catch (std::exception& e) {
95463       {
95464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95465       };
95466     } catch (Dali::DaliException e) {
95467       {
95468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95469       };
95470     } catch (...) {
95471       {
95472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95473       };
95474     }
95475   }
95476
95477   jresult = result;
95478   return jresult;
95479 }
95480
95481
95482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
95483   float jresult ;
95484   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95485   float arg2 ;
95486   float arg3 ;
95487   float arg4 ;
95488   float result;
95489
95490   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95491   arg2 = (float)jarg2;
95492   arg3 = (float)jarg3;
95493   arg4 = (float)jarg4;
95494   {
95495     try {
95496       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
95497     } catch (std::out_of_range& e) {
95498       {
95499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95500       };
95501     } catch (std::exception& e) {
95502       {
95503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95504       };
95505     } catch (Dali::DaliException e) {
95506       {
95507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95508       };
95509     } catch (...) {
95510       {
95511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95512       };
95513     }
95514   }
95515
95516   jresult = result;
95517   return jresult;
95518 }
95519
95520
95521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
95522   float jresult ;
95523   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95524   float arg2 ;
95525   float arg3 ;
95526   float result;
95527
95528   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95529   arg2 = (float)jarg2;
95530   arg3 = (float)jarg3;
95531   {
95532     try {
95533       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
95534     } catch (std::out_of_range& e) {
95535       {
95536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95537       };
95538     } catch (std::exception& e) {
95539       {
95540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95541       };
95542     } catch (Dali::DaliException e) {
95543       {
95544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95545       };
95546     } catch (...) {
95547       {
95548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95549       };
95550     }
95551   }
95552
95553   jresult = result;
95554   return jresult;
95555 }
95556
95557
95558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
95559   float jresult ;
95560   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95561   float arg2 ;
95562   float result;
95563
95564   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95565   arg2 = (float)jarg2;
95566   {
95567     try {
95568       result = (float)(*arg1)->SnapAndClamp(arg2);
95569     } catch (std::out_of_range& e) {
95570       {
95571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95572       };
95573     } catch (std::exception& e) {
95574       {
95575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95576       };
95577     } catch (Dali::DaliException e) {
95578       {
95579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95580       };
95581     } catch (...) {
95582       {
95583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95584       };
95585     }
95586   }
95587
95588   jresult = result;
95589   return jresult;
95590 }
95591
95592
95593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
95594   float jresult ;
95595   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95596   float arg2 ;
95597   float arg3 ;
95598   float arg4 ;
95599   float arg5 ;
95600   Dali::Toolkit::ClampState *arg6 = 0 ;
95601   float result;
95602
95603   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95604   arg2 = (float)jarg2;
95605   arg3 = (float)jarg3;
95606   arg4 = (float)jarg4;
95607   arg5 = (float)jarg5;
95608   arg6 = (Dali::Toolkit::ClampState *)jarg6;
95609   if (!arg6) {
95610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95611     return 0;
95612   }
95613   {
95614     try {
95615       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
95616     } catch (std::out_of_range& e) {
95617       {
95618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95619       };
95620     } catch (std::exception& e) {
95621       {
95622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95623       };
95624     } catch (Dali::DaliException e) {
95625       {
95626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95627       };
95628     } catch (...) {
95629       {
95630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95631       };
95632     }
95633   }
95634
95635   jresult = result;
95636   return jresult;
95637 }
95638
95639
95640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
95641   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95642
95643   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95644   {
95645     try {
95646       (*arg1)->Reference();
95647     } catch (std::out_of_range& e) {
95648       {
95649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95650       };
95651     } catch (std::exception& e) {
95652       {
95653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95654       };
95655     } catch (Dali::DaliException e) {
95656       {
95657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95658       };
95659     } catch (...) {
95660       {
95661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95662       };
95663     }
95664   }
95665
95666 }
95667
95668
95669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95670   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95671
95672   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95673   {
95674     try {
95675       (*arg1)->Unreference();
95676     } catch (std::out_of_range& e) {
95677       {
95678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95679       };
95680     } catch (std::exception& e) {
95681       {
95682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95683       };
95684     } catch (Dali::DaliException e) {
95685       {
95686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95687       };
95688     } catch (...) {
95689       {
95690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95691       };
95692     }
95693   }
95694
95695 }
95696
95697
95698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95699   int jresult ;
95700   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95701   int result;
95702
95703   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95704   {
95705     try {
95706       result = (int)(*arg1)->ReferenceCount();
95707     } catch (std::out_of_range& e) {
95708       {
95709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95710       };
95711     } catch (std::exception& e) {
95712       {
95713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95714       };
95715     } catch (Dali::DaliException e) {
95716       {
95717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95718       };
95719     } catch (...) {
95720       {
95721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95722       };
95723     }
95724   }
95725
95726   jresult = result;
95727   return jresult;
95728 }
95729
95730
95731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95732   unsigned int jresult ;
95733   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95734   bool result;
95735
95736   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95737   {
95738     try {
95739       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95740     } catch (std::out_of_range& e) {
95741       {
95742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95743       };
95744     } catch (std::exception& e) {
95745       {
95746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95747       };
95748     } catch (Dali::DaliException e) {
95749       {
95750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95751       };
95752     } catch (...) {
95753       {
95754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95755       };
95756     }
95757   }
95758
95759   jresult = result;
95760   return jresult;
95761 }
95762
95763
95764 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95765   unsigned long jresult ;
95766   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95767   std::size_t result;
95768
95769   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95770   {
95771     try {
95772       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95773     } catch (std::out_of_range& e) {
95774       {
95775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95776       };
95777     } catch (std::exception& e) {
95778       {
95779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95780       };
95781     } catch (Dali::DaliException e) {
95782       {
95783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95784       };
95785     } catch (...) {
95786       {
95787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95788       };
95789     }
95790   }
95791
95792   jresult = (unsigned long)result;
95793   return jresult;
95794 }
95795
95796
95797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95798   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95799   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95800
95801   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95802   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95803   {
95804     try {
95805       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95806     } catch (std::out_of_range& e) {
95807       {
95808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95809       };
95810     } catch (std::exception& e) {
95811       {
95812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95813       };
95814     } catch (Dali::DaliException e) {
95815       {
95816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95817       };
95818     } catch (...) {
95819       {
95820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95821       };
95822     }
95823   }
95824
95825 }
95826
95827
95828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95829   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95830   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95831
95832   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95833   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95834   {
95835     try {
95836       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95837     } catch (std::out_of_range& e) {
95838       {
95839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95840       };
95841     } catch (std::exception& e) {
95842       {
95843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95844       };
95845     } catch (Dali::DaliException e) {
95846       {
95847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95848       };
95849     } catch (...) {
95850       {
95851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95852       };
95853     }
95854   }
95855
95856 }
95857
95858
95859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95860   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95861   Dali::Toolkit::Control arg2 ;
95862   Dali::Toolkit::Control *argp2 ;
95863
95864   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95865   argp2 = (Dali::Toolkit::Control *)jarg2;
95866   if (!argp2) {
95867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95868     return ;
95869   }
95870   arg2 = *argp2;
95871   {
95872     try {
95873       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95874     } catch (std::out_of_range& e) {
95875       {
95876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95877       };
95878     } catch (std::exception& e) {
95879       {
95880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95881       };
95882     } catch (Dali::DaliException e) {
95883       {
95884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95885       };
95886     } catch (...) {
95887       {
95888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95889       };
95890     }
95891   }
95892
95893 }
95894
95895
95896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95897   void * jresult ;
95898   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95899
95900   {
95901     try {
95902       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95903     } catch (std::out_of_range& e) {
95904       {
95905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95906       };
95907     } catch (std::exception& e) {
95908       {
95909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95910       };
95911     } catch (Dali::DaliException e) {
95912       {
95913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95914       };
95915     } catch (...) {
95916       {
95917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95918       };
95919     }
95920   }
95921
95922   jresult = (void *)result;
95923   return jresult;
95924 }
95925
95926
95927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95928   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95929
95930   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95931   {
95932     try {
95933       delete arg1;
95934     } catch (std::out_of_range& e) {
95935       {
95936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95937       };
95938     } catch (std::exception& e) {
95939       {
95940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95941       };
95942     } catch (Dali::DaliException e) {
95943       {
95944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95945       };
95946     } catch (...) {
95947       {
95948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95949       };
95950     }
95951   }
95952
95953 }
95954
95955 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95956   Dali::RefObject *result = NULL;
95957
95958   if (arg1)
95959   {
95960     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95961   }
95962   return result;
95963 }
95964
95965 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95966     return (Dali::RefObject *)jarg1;
95967 }
95968
95969 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95970     return (Dali::SignalObserver *)jarg1;
95971 }
95972
95973 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95974     return (Dali::ConnectionTrackerInterface *)jarg1;
95975 }
95976
95977 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95978     return (Dali::BaseHandle *)jarg1;
95979 }
95980
95981 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95982     return (Dali::BaseHandle *)jarg1;
95983 }
95984
95985 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95986     return (Dali::BaseHandle *)jarg1;
95987 }
95988
95989 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95990     return (Dali::BaseHandle *)jarg1;
95991 }
95992
95993 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95994     return (Dali::BaseHandle *)jarg1;
95995 }
95996
95997 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95998     return (Dali::BaseHandle *)jarg1;
95999 }
96000
96001 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
96002     return (Dali::BaseHandle *)jarg1;
96003 }
96004
96005 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
96006     return (Dali::BaseHandle *)jarg1;
96007 }
96008
96009 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
96010     return (Dali::BaseHandle *)jarg1;
96011 }
96012
96013 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
96014     return (Dali::BaseHandle *)jarg1;
96015 }
96016
96017 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
96018     return (Dali::BaseHandle *)jarg1;
96019 }
96020
96021 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
96022     return (Dali::BaseHandle *)jarg1;
96023 }
96024
96025 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
96026     return (Dali::Handle *)jarg1;
96027 }
96028
96029 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
96030     return (Dali::Handle *)jarg1;
96031 }
96032
96033 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
96034     return (Dali::BaseHandle *)jarg1;
96035 }
96036
96037 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
96038     return (Dali::BaseHandle *)jarg1;
96039 }
96040
96041 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
96042     return (Dali::Handle *)jarg1;
96043 }
96044
96045 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
96046     return (Dali::BaseHandle *)jarg1;
96047 }
96048
96049 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
96050     return (Dali::Handle *)jarg1;
96051 }
96052
96053 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
96054     return (Dali::GestureDetector *)jarg1;
96055 }
96056
96057 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
96058     return (Dali::Gesture *)jarg1;
96059 }
96060
96061 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
96062     return (Dali::Handle *)jarg1;
96063 }
96064
96065 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
96066     return (Dali::Actor *)jarg1;
96067 }
96068
96069 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
96070     return (Dali::BaseHandle *)jarg1;
96071 }
96072
96073 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
96074     return (Dali::RefObject *)jarg1;
96075 }
96076
96077 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
96078     return (Dali::Actor *)jarg1;
96079 }
96080
96081 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
96082     return (Dali::GestureDetector *)jarg1;
96083 }
96084
96085 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
96086     return (Dali::Gesture *)jarg1;
96087 }
96088
96089 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
96090     return (Dali::GestureDetector *)jarg1;
96091 }
96092
96093 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
96094     return (Dali::Gesture *)jarg1;
96095 }
96096
96097 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
96098     return (Dali::GestureDetector *)jarg1;
96099 }
96100
96101 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
96102     return (Dali::Gesture *)jarg1;
96103 }
96104
96105 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
96106     return (Dali::BaseHandle *)jarg1;
96107 }
96108
96109 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
96110     return (Dali::Handle *)jarg1;
96111 }
96112
96113 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
96114     return (Dali::Handle *)jarg1;
96115 }
96116
96117 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
96118     return (Dali::Handle *)jarg1;
96119 }
96120
96121 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
96122     return (Dali::RefObject *)jarg1;
96123 }
96124
96125 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
96126     return (Dali::Actor *)jarg1;
96127 }
96128
96129 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
96130     return (Dali::BaseHandle *)jarg1;
96131 }
96132
96133 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
96134     return (Dali::BaseHandle *)jarg1;
96135 }
96136
96137 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
96138     return (Dali::BaseHandle *)jarg1;
96139 }
96140
96141 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
96142     return (Dali::CustomActorImpl *)jarg1;
96143 }
96144
96145 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
96146     return (Dali::CustomActor *)jarg1;
96147 }
96148
96149 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
96150     return (Dali::BaseHandle *)jarg1;
96151 }
96152
96153 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
96154     return (Dali::Toolkit::Control *)jarg1;
96155 }
96156
96157 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
96158     return (Dali::Toolkit::Control *)jarg1;
96159 }
96160
96161 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
96162     return (Dali::Toolkit::Button *)jarg1;
96163 }
96164
96165 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
96166     return (Dali::Toolkit::Button *)jarg1;
96167 }
96168
96169 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
96170     return (Dali::Toolkit::Button *)jarg1;
96171 }
96172
96173 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
96174     return (Dali::Toolkit::Control *)jarg1;
96175 }
96176
96177 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
96178     return (Dali::Toolkit::Control *)jarg1;
96179 }
96180
96181 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
96182     return (Dali::Toolkit::Control *)jarg1;
96183 }
96184
96185 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
96186     return (Dali::Toolkit::Control *)jarg1;
96187 }
96188
96189 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
96190     return (Dali::Toolkit::Control *)jarg1;
96191 }
96192
96193 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
96194     return (Dali::RefObject *)jarg1;
96195 }
96196
96197 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
96198     return (Dali::Toolkit::Scrollable *)jarg1;
96199 }
96200
96201 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
96202     return (Dali::BaseHandle *)jarg1;
96203 }
96204
96205 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
96206     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
96207 }
96208
96209 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
96210     return (Dali::RefObject *)jarg1;
96211 }
96212
96213 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
96214     return (Dali::Toolkit::Ruler *)jarg1;
96215 }
96216
96217 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
96218     return (Dali::Toolkit::Ruler *)jarg1;
96219 }
96220
96221 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
96222     return (Dali::Toolkit::Scrollable *)jarg1;
96223 }
96224
96225 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
96226     return (Dali::Toolkit::Control *)jarg1;
96227 }
96228
96229
96230 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
96231     return (Dali::Toolkit::Control *)jarg1;
96232 }
96233
96234 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
96235     return (Dali::BaseHandle *)jarg1;
96236 }
96237
96238 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
96239     return (Dali::BaseHandle *)jarg1;
96240 }
96241
96242 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
96243     return (Dali::Toolkit::Control *)jarg1;
96244 }
96245
96246 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
96247     return (Dali::Toolkit::Control *)jarg1;
96248 }
96249
96250 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
96251     return (Dali::Toolkit::Control *)jarg1;
96252 }
96253
96254 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
96255     return (Dali::Toolkit::Control *)jarg1;
96256 }
96257
96258 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
96259     return (Dali::Toolkit::Control *)jarg1;
96260 }
96261
96262 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
96263     return (Dali::Toolkit::Control *)jarg1;
96264 }
96265
96266 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
96267     return (Dali::Toolkit::PageTurnView *)jarg1;
96268 }
96269
96270 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
96271     return (Dali::Toolkit::PageTurnView *)jarg1;
96272 }
96273
96274 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
96275     return (Dali::Toolkit::Button *)jarg1;
96276 }
96277
96278 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
96279     return (Dali::BaseHandle *)jarg1;
96280 }
96281
96282 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
96283     return (Dali::BaseHandle *)jarg1;
96284 }
96285
96286 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
96287     return (Dali::BaseHandle *)jarg1;
96288 }
96289
96290 /*
96291  * Widget binding
96292  */
96293 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
96294     return (Dali::BaseHandle *)jarg1;
96295 }
96296
96297 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
96298     return (Dali::BaseObject *)jarg1;
96299 }
96300
96301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
96302   void * jresult ;
96303   Dali::Widget result;
96304
96305   {
96306     try {
96307       result = Dali::Widget::New();
96308     } catch (std::out_of_range& e) {
96309       {
96310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96311       };
96312     } catch (std::exception& e) {
96313       {
96314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96315       };
96316     } catch (...) {
96317       {
96318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96319       };
96320     }
96321   }
96322   jresult = new Dali::Widget((const Dali::Widget &)result);
96323   return jresult;
96324 }
96325
96326
96327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
96328   void * jresult ;
96329   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
96330   Dali::Widget result;
96331
96332   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96333
96334   if (!arg1) {
96335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
96336     return 0;
96337   }
96338   {
96339     try {
96340       jresult = new Dali::Widget(arg1);
96341     } catch (std::out_of_range& e) {
96342       {
96343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96344       };
96345     } catch (std::exception& e) {
96346       {
96347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96348       };
96349     } catch (...) {
96350       {
96351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96352       };
96353     }
96354   }
96355   return jresult;
96356 }
96357
96358
96359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
96360   void * jresult ;
96361   Dali::Widget *result = 0 ;
96362
96363   {
96364     try {
96365       result = (Dali::Widget *)new Dali::Widget();
96366     } catch (std::out_of_range& e) {
96367       {
96368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96369       };
96370     } catch (std::exception& e) {
96371       {
96372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96373       };
96374     } catch (...) {
96375       {
96376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96377       };
96378     }
96379   }
96380   jresult = (void *)result;
96381   return jresult;
96382 }
96383
96384
96385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
96386   void * jresult ;
96387   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
96388   Dali::Widget *arg2 = 0 ;
96389   Dali::Widget *result = 0 ;
96390
96391   arg1 = (Dali::Widget *)jarg1;
96392   arg2 = (Dali::Widget *)jarg2;
96393   if (!arg2) {
96394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
96395     return 0;
96396   }
96397   {
96398     try {
96399       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
96400     } catch (std::out_of_range& e) {
96401       {
96402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96403       };
96404     } catch (std::exception& e) {
96405       {
96406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96407       };
96408     } catch (...) {
96409       {
96410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96411       };
96412     }
96413   }
96414   jresult = (void *)result;
96415   return jresult;
96416 }
96417
96418
96419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
96420   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
96421
96422   arg1 = (Dali::Widget *)jarg1;
96423   {
96424     try {
96425       delete arg1;
96426     } catch (std::out_of_range& e) {
96427       {
96428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96429       };
96430     } catch (std::exception& e) {
96431       {
96432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96433       };
96434     } catch (...) {
96435       {
96436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96437       };
96438     }
96439   }
96440 }
96441
96442
96443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
96444   void * jresult ;
96445   SwigDirector_WidgetImpl* result;
96446   {
96447     try {
96448       result = new SwigDirector_WidgetImpl();
96449     } catch (std::out_of_range& e) {
96450       {
96451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96452       };
96453     } catch (std::exception& e) {
96454       {
96455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96456       };
96457     } catch (...) {
96458       {
96459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96460       };
96461     }
96462   }
96463   jresult = result;
96464   return jresult;
96465 }
96466
96467
96468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
96469   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96470   std::string *arg2 = 0 ;
96471   Dali::Window arg3 ;
96472   Dali::Window *argp3 ;
96473
96474   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96475   if (!jarg2) {
96476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96477     return ;
96478   }
96479   std::string arg2_str(jarg2);
96480   arg2 = &arg2_str;
96481   argp3 = (Dali::Window *)jarg3;
96482   if (!argp3) {
96483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96484     return ;
96485   }
96486   arg3 = *argp3;
96487   {
96488     try {
96489       (arg1)->OnCreate((std::string const &)*arg2,arg3);
96490     } catch (std::out_of_range& e) {
96491       {
96492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96493       };
96494     } catch (std::exception& e) {
96495       {
96496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96497       };
96498     } catch (...) {
96499       {
96500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96501       };
96502     }
96503   }
96504 }
96505
96506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
96507   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96508   std::string *arg2 = 0 ;
96509   Dali::Window arg3 ;
96510   Dali::Window *argp3 ;
96511
96512   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96513   if (!jarg2) {
96514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96515     return ;
96516   }
96517   std::string arg2_str(jarg2);
96518   arg2 = &arg2_str;
96519   argp3 = (Dali::Window *)jarg3;
96520   if (!argp3) {
96521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96522     return ;
96523   }
96524   arg3 = *argp3;
96525   {
96526     try {
96527       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
96528     } catch (std::out_of_range& e) {
96529       {
96530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96531       };
96532     } catch (std::exception& e) {
96533       {
96534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96535       };
96536     } catch (...) {
96537       {
96538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96539       };
96540     }
96541   }
96542 }
96543
96544
96545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
96546   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96547   std::string *arg2 = 0 ;
96548   Dali::Widget::Termination arg3 ;
96549
96550   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96551   if (!jarg2) {
96552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96553     return ;
96554   }
96555   std::string arg2_str(jarg2);
96556   arg2 = &arg2_str;
96557   arg3 = (Dali::Widget::Termination)jarg3;
96558   {
96559     try {
96560       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
96561     } catch (std::out_of_range& e) {
96562       {
96563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96564       };
96565     } catch (std::exception& e) {
96566       {
96567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96568       };
96569     } catch (...) {
96570       {
96571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96572       };
96573     }
96574   }
96575 }
96576
96577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96578   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96579   std::string *arg2 = 0 ;
96580   Dali::Widget::Termination arg3 ;
96581
96582   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96583   if (!jarg2) {
96584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96585     return ;
96586   }
96587   std::string arg2_str(jarg2);
96588   arg2 = &arg2_str;
96589   arg3 = (Dali::Widget::Termination)jarg3;
96590   {
96591     try {
96592       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
96593     } catch (std::out_of_range& e) {
96594       {
96595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96596       };
96597     } catch (std::exception& e) {
96598       {
96599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96600       };
96601     } catch (...) {
96602       {
96603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96604       };
96605     }
96606   }
96607 }
96608
96609
96610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
96611   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96612
96613   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96614   {
96615     try {
96616       (arg1)->OnPause();
96617     } catch (std::out_of_range& e) {
96618       {
96619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96620       };
96621     } catch (std::exception& e) {
96622       {
96623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96624       };
96625     } catch (...) {
96626       {
96627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96628       };
96629     }
96630   }
96631 }
96632
96633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
96634   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96635
96636   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96637   {
96638     try {
96639       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
96640     } catch (std::out_of_range& e) {
96641       {
96642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96643       };
96644     } catch (std::exception& e) {
96645       {
96646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96647       };
96648     } catch (...) {
96649       {
96650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96651       };
96652     }
96653   }
96654 }
96655
96656
96657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
96658   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96659
96660   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96661   {
96662     try {
96663       (arg1)->OnResume();
96664     } catch (std::out_of_range& e) {
96665       {
96666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96667       };
96668     } catch (std::exception& e) {
96669       {
96670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96671       };
96672     } catch (...) {
96673       {
96674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96675       };
96676     }
96677   }
96678 }
96679
96680
96681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96682   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96683
96684   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96685   {
96686     try {
96687       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96688     } catch (std::out_of_range& e) {
96689       {
96690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96691       };
96692     } catch (std::exception& e) {
96693       {
96694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96695       };
96696     } catch (...) {
96697       {
96698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96699       };
96700     }
96701   }
96702 }
96703
96704
96705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96706   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96707   Dali::Window arg2 ;
96708   Dali::Window *argp2 ;
96709
96710   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96711   argp2 = (Dali::Window *)jarg2;
96712   if (!argp2) {
96713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96714     return ;
96715   }
96716   arg2 = *argp2;
96717   {
96718     try {
96719       (arg1)->OnResize(arg2);
96720     } catch (std::out_of_range& e) {
96721       {
96722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96723       };
96724     } catch (std::exception& e) {
96725       {
96726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96727       };
96728     } catch (...) {
96729       {
96730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96731       };
96732     }
96733   }
96734 }
96735
96736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96737   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96738   Dali::Window arg2 ;
96739   Dali::Window *argp2 ;
96740
96741   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96742   argp2 = (Dali::Window *)jarg2;
96743   if (!argp2) {
96744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96745     return ;
96746   }
96747   arg2 = *argp2;
96748   {
96749     try {
96750       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96751     } catch (std::out_of_range& e) {
96752       {
96753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96754       };
96755     } catch (std::exception& e) {
96756       {
96757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96758       };
96759     } catch (...) {
96760       {
96761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96762       };
96763     }
96764   }
96765 }
96766
96767
96768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96769   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96770   std::string *arg2 = 0 ;
96771   int arg3 ;
96772
96773   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96774   if (!jarg2) {
96775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96776     return ;
96777   }
96778   std::string arg2_str(jarg2);
96779   arg2 = &arg2_str;
96780   arg3 = (int)jarg3;
96781   {
96782     try {
96783       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96784     } catch (std::out_of_range& e) {
96785       {
96786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96787       };
96788     } catch (std::exception& e) {
96789       {
96790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96791       };
96792     } catch (...) {
96793       {
96794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96795       };
96796     }
96797   }
96798 }
96799
96800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96801   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96802   std::string *arg2 = 0 ;
96803   int arg3 ;
96804
96805   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96806   if (!jarg2) {
96807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96808     return ;
96809   }
96810   std::string arg2_str(jarg2);
96811   arg2 = &arg2_str;
96812   arg3 = (int)jarg3;
96813   {
96814     try {
96815       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96816     } catch (std::out_of_range& e) {
96817       {
96818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96819       };
96820     } catch (std::exception& e) {
96821       {
96822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96823       };
96824     } catch (...) {
96825       {
96826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96827       };
96828     }
96829   }
96830 }
96831
96832
96833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96834   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96835   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96836   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96837
96838   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96839   arg2 = (Dali::SlotObserver *)jarg2;
96840   arg3 = (Dali::CallbackBase *)jarg3;
96841   {
96842     try {
96843       (arg1)->SignalConnected(arg2,arg3);
96844     } catch (std::out_of_range& e) {
96845       {
96846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96847       };
96848     } catch (std::exception& e) {
96849       {
96850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96851       };
96852     } catch (...) {
96853       {
96854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96855       };
96856     }
96857   }
96858 }
96859
96860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96861   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96862   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96863   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96864
96865   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96866   arg2 = (Dali::SlotObserver *)jarg2;
96867   arg3 = (Dali::CallbackBase *)jarg3;
96868   {
96869     try {
96870       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96871     } catch (std::out_of_range& e) {
96872       {
96873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96874       };
96875     } catch (std::exception& e) {
96876       {
96877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96878       };
96879     } catch (...) {
96880       {
96881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96882       };
96883     }
96884   }
96885 }
96886
96887
96888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96889   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96890   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96891   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96892
96893   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96894   arg2 = (Dali::SlotObserver *)jarg2;
96895   arg3 = (Dali::CallbackBase *)jarg3;
96896   {
96897     try {
96898       (arg1)->SignalDisconnected(arg2,arg3);
96899     } catch (std::out_of_range& e) {
96900       {
96901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96902       };
96903     } catch (std::exception& e) {
96904       {
96905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96906       };
96907     } catch (...) {
96908       {
96909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96910       };
96911     }
96912   }
96913 }
96914
96915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96916   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96917   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96918   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96919
96920   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96921   arg2 = (Dali::SlotObserver *)jarg2;
96922   arg3 = (Dali::CallbackBase *)jarg3;
96923   {
96924     try {
96925       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96926     } catch (std::out_of_range& e) {
96927       {
96928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96929       };
96930     } catch (std::exception& e) {
96931       {
96932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96933       };
96934     } catch (...) {
96935       {
96936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96937       };
96938     }
96939   }
96940 }
96941
96942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96943   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96944   std::string *arg2 = 0 ;
96945
96946   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96947   if (!jarg2) {
96948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96949     return ;
96950   }
96951   std::string arg2_str(jarg2);
96952   arg2 = &arg2_str;
96953   {
96954     try {
96955       (arg1)->SetContentInfo((std::string const &)*arg2);
96956     } catch (std::out_of_range& e) {
96957       {
96958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96959       };
96960     } catch (std::exception& e) {
96961       {
96962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96963       };
96964     } catch (...) {
96965       {
96966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96967       };
96968     }
96969   }
96970 }
96971
96972
96973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96974   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96975   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96976
96977   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96978   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96979   {
96980     try {
96981       (arg1)->SetImpl(arg2);
96982     } catch (std::out_of_range& e) {
96983       {
96984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96985       };
96986     } catch (std::exception& e) {
96987       {
96988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96989       };
96990     } catch (...) {
96991       {
96992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96993       };
96994     }
96995   }
96996 }
96997
96998 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) {
96999
97000   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
97001   if (director) {
97002     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
97003   }
97004 }
97005
97006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
97007   void * jresult ;
97008   Dali::Widget *arg1 = 0 ;
97009   SwigDirector_WidgetImpl *result = 0 ;
97010
97011   arg1 = (Dali::Widget *)jarg1;
97012   if (!arg1) {
97013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
97014     return 0;
97015   }
97016   {
97017     try {
97018       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
97019     } catch (std::out_of_range& e) {
97020       {
97021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97022       };
97023     } catch (std::exception& e) {
97024       {
97025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97026       };
97027     } catch (...) {
97028       {
97029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97030       };
97031     }
97032   }
97033
97034   jresult = (void *)result;
97035   return jresult;
97036 }
97037
97038
97039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
97040   void * jresult ;
97041   int *arg1 = (int *) 0 ;
97042   char ***arg2 ;
97043   std::string *arg3 = 0 ;
97044   Dali::WidgetApplication result;
97045   {
97046     int index = 0;
97047     int length = 0;
97048     char *retPtr;
97049     char *nextPtr;
97050     argWidgetC = jarg1;
97051     argWidgetV = new char*[jarg1 + 1];
97052
97053     retPtr = strtok_r( jarg2, " ", &nextPtr);
97054     if( retPtr )
97055     {
97056       length = strlen(retPtr);
97057     }
97058     argWidgetV[index] = new char[length + 1];
97059     if( retPtr )
97060     {
97061       strncpy(argWidgetV[index], retPtr, length);
97062     }
97063     argWidgetV[index][length] = '\0';
97064     index++;
97065
97066     while (index < jarg1)
97067     {
97068       length = 0;
97069       retPtr = strtok_r(NULL, " ", &nextPtr);
97070       if( retPtr )
97071       {
97072         length = strlen(retPtr);
97073       }
97074       argWidgetV[index] = new char[length + 1];
97075       if( retPtr )
97076       {
97077         strncpy(argWidgetV[index], retPtr, length);
97078       }
97079       argWidgetV[index][length] = '\0';
97080       index++;
97081     }
97082
97083     argWidgetV[jarg1] = NULL;
97084     argWidgetC = jarg1;
97085
97086     arg1 = &argWidgetC;
97087     arg2 = &argWidgetV;
97088   }
97089
97090   if (!jarg3) {
97091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97092     return 0;
97093   }
97094   std::string arg3_str(jarg3);
97095   arg3 = &arg3_str;
97096   {
97097     try {
97098       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
97099     } catch (std::out_of_range& e) {
97100       {
97101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97102       };
97103     } catch (std::exception& e) {
97104       {
97105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97106       };
97107     } catch (...) {
97108       {
97109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97110       };
97111     }
97112   }
97113   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
97114
97115   return jresult;
97116 }
97117
97118
97119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
97120   void * jresult ;
97121   Dali::WidgetApplication *result = 0 ;
97122
97123   {
97124     try {
97125       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
97126     } catch (std::out_of_range& e) {
97127       {
97128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97129       };
97130     } catch (std::exception& e) {
97131       {
97132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97133       };
97134     } catch (...) {
97135       {
97136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97137       };
97138     }
97139   }
97140   jresult = (void *)result;
97141   return jresult;
97142 }
97143
97144
97145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
97146   void * jresult ;
97147   Dali::WidgetApplication *arg1 = 0 ;
97148   Dali::WidgetApplication *result = 0 ;
97149
97150   arg1 = (Dali::WidgetApplication *)jarg1;
97151   if (!arg1) {
97152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
97153     return 0;
97154   }
97155   {
97156     try {
97157       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
97158     } catch (std::out_of_range& e) {
97159       {
97160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97161       };
97162     } catch (std::exception& e) {
97163       {
97164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97165       };
97166     } catch (...) {
97167       {
97168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97169       };
97170     }
97171   }
97172   jresult = (void *)result;
97173   return jresult;
97174 }
97175
97176
97177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
97178   void * jresult ;
97179   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
97180   Dali::WidgetApplication *arg2 = 0 ;
97181   Dali::WidgetApplication *result = 0 ;
97182
97183   arg1 = (Dali::WidgetApplication *)jarg1;
97184   arg2 = (Dali::WidgetApplication *)jarg2;
97185   if (!arg2) {
97186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
97187     return 0;
97188   }
97189   {
97190     try {
97191       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
97192     } catch (std::out_of_range& e) {
97193       {
97194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97195       };
97196     } catch (std::exception& e) {
97197       {
97198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97199       };
97200     } catch (...) {
97201       {
97202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97203       };
97204     }
97205   }
97206   jresult = (void *)result;
97207   return jresult;
97208 }
97209
97210
97211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
97212   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
97213
97214   arg1 = (Dali::WidgetApplication *)jarg1;
97215   {
97216     try {
97217       delete arg1;
97218       if( argWidgetV )
97219       {
97220         // free string data
97221         for( int i=0; i < argWidgetC+1; i++)
97222         {
97223           delete [] argWidgetV[i];
97224         }
97225         delete [] argWidgetV;
97226       }
97227     } catch (std::out_of_range& e) {
97228       {
97229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97230       };
97231     } catch (std::exception& e) {
97232       {
97233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97234       };
97235     } catch (...) {
97236       {
97237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97238       };
97239     }
97240   }
97241 }
97242
97243
97244 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
97245 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
97246
97247 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
97248 {
97249   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
97250   return *widget;
97251 }
97252
97253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
97254   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
97255   std::string *arg2 = 0 ;
97256
97257   arg1 = (Dali::WidgetApplication *)jarg1;
97258   if (!jarg2) {
97259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97260     return ;
97261   }
97262   std::string arg2_str(*jarg2);
97263   arg2 = &arg2_str;
97264
97265   if(!_CSharpCreateWidgetFunction)
97266   {
97267     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
97268   }
97269
97270   {
97271     try {
97272       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
97273     } catch (std::out_of_range& e) {
97274       {
97275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97276       };
97277     } catch (std::exception& e) {
97278       {
97279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97280       };
97281     } catch (...) {
97282       {
97283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97284       };
97285     }
97286   }
97287
97288   //Typemap argout in c++ file.
97289   //This will convert c++ string to c# string
97290   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
97291 }
97292
97293
97294 //for PixelBuffer and ImageLoading
97295
97296 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
97297     return (Dali::BaseHandle *)jarg1;
97298 }
97299
97300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
97301   void * jresult ;
97302   unsigned int arg1 ;
97303   unsigned int arg2 ;
97304   Dali::Pixel::Format arg3 ;
97305   Dali::Devel::PixelBuffer result;
97306
97307   arg1 = (unsigned int)jarg1;
97308   arg2 = (unsigned int)jarg2;
97309   arg3 = (Dali::Pixel::Format)jarg3;
97310   {
97311     try {
97312       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
97313     } catch (std::out_of_range& e) {
97314       {
97315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97316       };
97317     } catch (std::exception& e) {
97318       {
97319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97320       };
97321     } catch (...) {
97322       {
97323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97324       };
97325     }
97326   }
97327   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97328   return jresult;
97329 }
97330
97331
97332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
97333   void * jresult ;
97334   Dali::Devel::PixelBuffer *result = 0 ;
97335
97336   {
97337     try {
97338       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
97339     } catch (std::out_of_range& e) {
97340       {
97341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97342       };
97343     } catch (std::exception& e) {
97344       {
97345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97346       };
97347     } catch (...) {
97348       {
97349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97350       };
97351     }
97352   }
97353   jresult = (void *)result;
97354   return jresult;
97355 }
97356
97357
97358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
97359   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97360
97361   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97362   {
97363     try {
97364       delete arg1;
97365     } catch (std::out_of_range& e) {
97366       {
97367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97368       };
97369     } catch (std::exception& e) {
97370       {
97371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97372       };
97373     } catch (...) {
97374       {
97375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97376       };
97377     }
97378   }
97379 }
97380
97381
97382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
97383   void * jresult ;
97384   Dali::Devel::PixelBuffer *arg1 = 0 ;
97385   Dali::Devel::PixelBuffer *result = 0 ;
97386
97387   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97388   if (!arg1) {
97389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
97390     return 0;
97391   }
97392   {
97393     try {
97394       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
97395     } catch (std::out_of_range& e) {
97396       {
97397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97398       };
97399     } catch (std::exception& e) {
97400       {
97401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97402       };
97403     } catch (...) {
97404       {
97405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97406       };
97407     }
97408   }
97409   jresult = (void *)result;
97410   return jresult;
97411 }
97412
97413
97414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
97415   void * jresult ;
97416   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97417   Dali::Devel::PixelBuffer *arg2 = 0 ;
97418   Dali::Devel::PixelBuffer *result = 0 ;
97419
97420   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97421   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
97422   if (!arg2) {
97423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
97424     return 0;
97425   }
97426   {
97427     try {
97428       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
97429     } catch (std::out_of_range& e) {
97430       {
97431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97432       };
97433     } catch (std::exception& e) {
97434       {
97435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97436       };
97437     } catch (...) {
97438       {
97439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97440       };
97441     }
97442   }
97443   jresult = (void *)result;
97444   return jresult;
97445 }
97446
97447
97448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
97449   void * jresult ;
97450   Dali::Devel::PixelBuffer *arg1 = 0 ;
97451   Dali::PixelData result;
97452
97453   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97454   if (!arg1) {
97455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
97456     return 0;
97457   }
97458   {
97459     try {
97460       result = Dali::Devel::PixelBuffer::Convert(*arg1);
97461     } catch (std::out_of_range& e) {
97462       {
97463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97464       };
97465     } catch (std::exception& e) {
97466       {
97467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97468       };
97469     } catch (...) {
97470       {
97471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97472       };
97473     }
97474   }
97475   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97476   return jresult;
97477 }
97478
97479
97480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
97481   void * jresult ;
97482   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97483   Dali::PixelData result;
97484
97485   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97486   {
97487     try {
97488       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
97489     } catch (std::out_of_range& e) {
97490       {
97491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97492       };
97493     } catch (std::exception& e) {
97494       {
97495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97496       };
97497     } catch (...) {
97498       {
97499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97500       };
97501     }
97502   }
97503   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97504   return jresult;
97505 }
97506
97507
97508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
97509   void * jresult ;
97510   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97511   unsigned char *result = 0 ;
97512
97513   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97514   {
97515     try {
97516       result = (unsigned char *)(arg1)->GetBuffer();
97517     } catch (std::out_of_range& e) {
97518       {
97519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97520       };
97521     } catch (std::exception& e) {
97522       {
97523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97524       };
97525     } catch (...) {
97526       {
97527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97528       };
97529     }
97530   }
97531   jresult = (void *)result;
97532   return jresult;
97533 }
97534
97535
97536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
97537   unsigned int jresult ;
97538   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97539   unsigned int result;
97540
97541   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97542   {
97543     try {
97544       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
97545     } catch (std::out_of_range& e) {
97546       {
97547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97548       };
97549     } catch (std::exception& e) {
97550       {
97551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97552       };
97553     } catch (...) {
97554       {
97555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97556       };
97557     }
97558   }
97559   jresult = result;
97560   return jresult;
97561 }
97562
97563
97564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
97565   unsigned int jresult ;
97566   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97567   unsigned int result;
97568
97569   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97570   {
97571     try {
97572       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
97573     } catch (std::out_of_range& e) {
97574       {
97575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97576       };
97577     } catch (std::exception& e) {
97578       {
97579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97580       };
97581     } catch (...) {
97582       {
97583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97584       };
97585     }
97586   }
97587   jresult = result;
97588   return jresult;
97589 }
97590
97591
97592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
97593   int jresult ;
97594   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97595   Dali::Pixel::Format result;
97596
97597   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97598   {
97599     try {
97600       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
97601     } catch (std::out_of_range& e) {
97602       {
97603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97604       };
97605     } catch (std::exception& e) {
97606       {
97607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97608       };
97609     } catch (...) {
97610       {
97611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97612       };
97613     }
97614   }
97615   jresult = (int)result;
97616   return jresult;
97617 }
97618
97619
97620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
97621   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97622   Dali::Devel::PixelBuffer arg2 ;
97623   float arg3 ;
97624   bool arg4 ;
97625   Dali::Devel::PixelBuffer *argp2 ;
97626
97627   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97628   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97629   if (!argp2) {
97630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97631     return ;
97632   }
97633   arg2 = *argp2;
97634   arg3 = (float)jarg3;
97635   arg4 = jarg4 ? true : false;
97636   {
97637     try {
97638       (arg1)->ApplyMask(arg2,arg3,arg4);
97639     } catch (std::out_of_range& e) {
97640       {
97641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97642       };
97643     } catch (std::exception& e) {
97644       {
97645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97646       };
97647     } catch (...) {
97648       {
97649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97650       };
97651     }
97652   }
97653 }
97654
97655
97656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
97657   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97658   Dali::Devel::PixelBuffer arg2 ;
97659   float arg3 ;
97660   Dali::Devel::PixelBuffer *argp2 ;
97661
97662   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97663   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97664   if (!argp2) {
97665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97666     return ;
97667   }
97668   arg2 = *argp2;
97669   arg3 = (float)jarg3;
97670   {
97671     try {
97672       (arg1)->ApplyMask(arg2,arg3);
97673     } catch (std::out_of_range& e) {
97674       {
97675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97676       };
97677     } catch (std::exception& e) {
97678       {
97679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97680       };
97681     } catch (...) {
97682       {
97683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97684       };
97685     }
97686   }
97687 }
97688
97689
97690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97691   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97692   Dali::Devel::PixelBuffer arg2 ;
97693   Dali::Devel::PixelBuffer *argp2 ;
97694
97695   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97696   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97697   if (!argp2) {
97698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97699     return ;
97700   }
97701   arg2 = *argp2;
97702   {
97703     try {
97704       (arg1)->ApplyMask(arg2);
97705     } catch (std::out_of_range& e) {
97706       {
97707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97708       };
97709     } catch (std::exception& e) {
97710       {
97711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97712       };
97713     } catch (...) {
97714       {
97715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97716       };
97717     }
97718   }
97719 }
97720
97721
97722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
97723   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97724   float arg2 ;
97725
97726   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97727   arg2 = (float)jarg2;
97728   {
97729     try {
97730       (arg1)->ApplyGaussianBlur(arg2);
97731     } catch (std::out_of_range& e) {
97732       {
97733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97734       };
97735     } catch (std::exception& e) {
97736       {
97737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97738       };
97739     } catch (...) {
97740       {
97741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97742       };
97743     }
97744   }
97745 }
97746
97747
97748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97749   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97750   uint16_t arg2 ;
97751   uint16_t arg3 ;
97752   uint16_t arg4 ;
97753   uint16_t arg5 ;
97754
97755   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97756   arg2 = (uint16_t)jarg2;
97757   arg3 = (uint16_t)jarg3;
97758   arg4 = (uint16_t)jarg4;
97759   arg5 = (uint16_t)jarg5;
97760   {
97761     try {
97762       (arg1)->Crop(arg2,arg3,arg4,arg5);
97763     } catch (std::out_of_range& e) {
97764       {
97765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97766       };
97767     } catch (std::exception& e) {
97768       {
97769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97770       };
97771     } catch (...) {
97772       {
97773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97774       };
97775     }
97776   }
97777 }
97778
97779
97780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97781   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97782   uint16_t arg2 ;
97783   uint16_t arg3 ;
97784
97785   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97786   arg2 = (uint16_t)jarg2;
97787   arg3 = (uint16_t)jarg3;
97788   {
97789     try {
97790       (arg1)->Resize(arg2,arg3);
97791     } catch (std::out_of_range& e) {
97792       {
97793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97794       };
97795     } catch (std::exception& e) {
97796       {
97797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97798       };
97799     } catch (...) {
97800       {
97801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97802       };
97803     }
97804   }
97805 }
97806
97807 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97808   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97809   Dali::Degree * arg2 ;
97810
97811   bool result = false;
97812
97813   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97814   arg2 = (Dali::Degree *)jarg2;
97815   {
97816     try {
97817       result = (arg1)->Rotate(*arg2);
97818     } catch (std::out_of_range& e) {
97819       {
97820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97821       };
97822     } catch (std::exception& e) {
97823       {
97824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97825       };
97826     } catch (...) {
97827       {
97828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97829       };
97830     }
97831   }
97832   return result;
97833 }
97834
97835
97836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97837   void * jresult ;
97838   std::string *arg1 = 0 ;
97839   Dali::ImageDimensions arg2 ;
97840   Dali::FittingMode::Type arg3 ;
97841   Dali::SamplingMode::Type arg4 ;
97842   bool arg5 ;
97843   Dali::ImageDimensions *argp2 ;
97844   Dali::Devel::PixelBuffer result;
97845
97846   if (!jarg1) {
97847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97848     return 0;
97849   }
97850   std::string arg1_str(jarg1);
97851   arg1 = &arg1_str;
97852   argp2 = (Dali::ImageDimensions *)jarg2;
97853   if (!argp2) {
97854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97855     return 0;
97856   }
97857   arg2 = *argp2;
97858   arg3 = (Dali::FittingMode::Type)jarg3;
97859   arg4 = (Dali::SamplingMode::Type)jarg4;
97860   arg5 = jarg5 ? true : false;
97861   {
97862     try {
97863       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97864     } catch (std::out_of_range& e) {
97865       {
97866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97867       };
97868     } catch (std::exception& e) {
97869       {
97870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97871       };
97872     } catch (...) {
97873       {
97874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97875       };
97876     }
97877   }
97878   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97879
97880   return jresult;
97881 }
97882
97883
97884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97885   void * jresult ;
97886   std::string *arg1 = 0 ;
97887   Dali::ImageDimensions arg2 ;
97888   Dali::FittingMode::Type arg3 ;
97889   Dali::SamplingMode::Type arg4 ;
97890   Dali::ImageDimensions *argp2 ;
97891   Dali::Devel::PixelBuffer result;
97892
97893   if (!jarg1) {
97894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97895     return 0;
97896   }
97897   std::string arg1_str(jarg1);
97898   arg1 = &arg1_str;
97899   argp2 = (Dali::ImageDimensions *)jarg2;
97900   if (!argp2) {
97901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97902     return 0;
97903   }
97904   arg2 = *argp2;
97905   arg3 = (Dali::FittingMode::Type)jarg3;
97906   arg4 = (Dali::SamplingMode::Type)jarg4;
97907   {
97908     try {
97909       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97910     } catch (std::out_of_range& e) {
97911       {
97912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97913       };
97914     } catch (std::exception& e) {
97915       {
97916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97917       };
97918     } catch (...) {
97919       {
97920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97921       };
97922     }
97923   }
97924   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97925
97926   return jresult;
97927 }
97928
97929
97930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97931   void * jresult ;
97932   std::string *arg1 = 0 ;
97933   Dali::ImageDimensions arg2 ;
97934   Dali::FittingMode::Type arg3 ;
97935   Dali::ImageDimensions *argp2 ;
97936   Dali::Devel::PixelBuffer result;
97937
97938   if (!jarg1) {
97939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97940     return 0;
97941   }
97942   std::string arg1_str(jarg1);
97943   arg1 = &arg1_str;
97944   argp2 = (Dali::ImageDimensions *)jarg2;
97945   if (!argp2) {
97946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97947     return 0;
97948   }
97949   arg2 = *argp2;
97950   arg3 = (Dali::FittingMode::Type)jarg3;
97951   {
97952     try {
97953       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97954     } catch (std::out_of_range& e) {
97955       {
97956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97957       };
97958     } catch (std::exception& e) {
97959       {
97960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97961       };
97962     } catch (...) {
97963       {
97964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97965       };
97966     }
97967   }
97968   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97969
97970   return jresult;
97971 }
97972
97973
97974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97975   void * jresult ;
97976   std::string *arg1 = 0 ;
97977   Dali::ImageDimensions arg2 ;
97978   Dali::ImageDimensions *argp2 ;
97979   Dali::Devel::PixelBuffer result;
97980
97981   if (!jarg1) {
97982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97983     return 0;
97984   }
97985   std::string arg1_str(jarg1);
97986   arg1 = &arg1_str;
97987   argp2 = (Dali::ImageDimensions *)jarg2;
97988   if (!argp2) {
97989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97990     return 0;
97991   }
97992   arg2 = *argp2;
97993   {
97994     try {
97995       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97996     } catch (std::out_of_range& e) {
97997       {
97998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97999       };
98000     } catch (std::exception& e) {
98001       {
98002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98003       };
98004     } catch (...) {
98005       {
98006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98007       };
98008     }
98009   }
98010   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98011
98012   return jresult;
98013 }
98014
98015
98016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
98017   void * jresult ;
98018   std::string *arg1 = 0 ;
98019   Dali::Devel::PixelBuffer result;
98020
98021   if (!jarg1) {
98022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98023     return 0;
98024   }
98025   std::string arg1_str(jarg1);
98026   arg1 = &arg1_str;
98027   {
98028     try {
98029       result = Dali::LoadImageFromFile((std::string const &)*arg1);
98030     } catch (std::out_of_range& e) {
98031       {
98032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98033       };
98034     } catch (std::exception& e) {
98035       {
98036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98037       };
98038     } catch (...) {
98039       {
98040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98041       };
98042     }
98043   }
98044   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98045
98046   return jresult;
98047 }
98048
98049
98050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
98051   void * jresult ;
98052   std::string *arg1 = 0 ;
98053   Dali::ImageDimensions arg2 ;
98054   Dali::FittingMode::Type arg3 ;
98055   Dali::SamplingMode::Type arg4 ;
98056   bool arg5 ;
98057   Dali::ImageDimensions *argp2 ;
98058   Dali::ImageDimensions result;
98059
98060   if (!jarg1) {
98061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98062     return 0;
98063   }
98064   std::string arg1_str(jarg1);
98065   arg1 = &arg1_str;
98066   argp2 = (Dali::ImageDimensions *)jarg2;
98067   if (!argp2) {
98068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98069     return 0;
98070   }
98071   arg2 = *argp2;
98072   arg3 = (Dali::FittingMode::Type)jarg3;
98073   arg4 = (Dali::SamplingMode::Type)jarg4;
98074   arg5 = jarg5 ? true : false;
98075   {
98076     try {
98077       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
98078     } catch (std::out_of_range& e) {
98079       {
98080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98081       };
98082     } catch (std::exception& e) {
98083       {
98084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98085       };
98086     } catch (...) {
98087       {
98088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98089       };
98090     }
98091   }
98092   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
98093
98094   return jresult;
98095 }
98096
98097
98098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
98099   void * jresult ;
98100   std::string *arg1 = 0 ;
98101   Dali::ImageDimensions arg2 ;
98102   Dali::FittingMode::Type arg3 ;
98103   Dali::SamplingMode::Type arg4 ;
98104   Dali::ImageDimensions *argp2 ;
98105   Dali::ImageDimensions result;
98106
98107   if (!jarg1) {
98108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98109     return 0;
98110   }
98111   std::string arg1_str(jarg1);
98112   arg1 = &arg1_str;
98113   argp2 = (Dali::ImageDimensions *)jarg2;
98114   if (!argp2) {
98115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98116     return 0;
98117   }
98118   arg2 = *argp2;
98119   arg3 = (Dali::FittingMode::Type)jarg3;
98120   arg4 = (Dali::SamplingMode::Type)jarg4;
98121   {
98122     try {
98123       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
98124     } catch (std::out_of_range& e) {
98125       {
98126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98127       };
98128     } catch (std::exception& e) {
98129       {
98130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98131       };
98132     } catch (...) {
98133       {
98134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98135       };
98136     }
98137   }
98138   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
98139
98140   return jresult;
98141 }
98142
98143
98144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
98145   void * jresult ;
98146   std::string *arg1 = 0 ;
98147   Dali::ImageDimensions arg2 ;
98148   Dali::FittingMode::Type arg3 ;
98149   Dali::ImageDimensions *argp2 ;
98150   Dali::ImageDimensions result;
98151
98152   if (!jarg1) {
98153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98154     return 0;
98155   }
98156   std::string arg1_str(jarg1);
98157   arg1 = &arg1_str;
98158   argp2 = (Dali::ImageDimensions *)jarg2;
98159   if (!argp2) {
98160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98161     return 0;
98162   }
98163   arg2 = *argp2;
98164   arg3 = (Dali::FittingMode::Type)jarg3;
98165   {
98166     try {
98167       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
98168     } catch (std::out_of_range& e) {
98169       {
98170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98171       };
98172     } catch (std::exception& e) {
98173       {
98174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98175       };
98176     } catch (...) {
98177       {
98178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98179       };
98180     }
98181   }
98182   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
98183
98184   return jresult;
98185 }
98186
98187
98188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
98189   void * jresult ;
98190   std::string *arg1 = 0 ;
98191   Dali::ImageDimensions arg2 ;
98192   Dali::ImageDimensions *argp2 ;
98193   Dali::ImageDimensions result;
98194
98195   if (!jarg1) {
98196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98197     return 0;
98198   }
98199   std::string arg1_str(jarg1);
98200   arg1 = &arg1_str;
98201   argp2 = (Dali::ImageDimensions *)jarg2;
98202   if (!argp2) {
98203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98204     return 0;
98205   }
98206   arg2 = *argp2;
98207   {
98208     try {
98209       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
98210     } catch (std::out_of_range& e) {
98211       {
98212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98213       };
98214     } catch (std::exception& e) {
98215       {
98216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98217       };
98218     } catch (...) {
98219       {
98220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98221       };
98222     }
98223   }
98224   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
98225
98226   return jresult;
98227 }
98228
98229
98230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
98231   void * jresult ;
98232   std::string *arg1 = 0 ;
98233   Dali::ImageDimensions result;
98234
98235   if (!jarg1) {
98236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98237     return 0;
98238   }
98239   std::string arg1_str(jarg1);
98240   arg1 = &arg1_str;
98241   {
98242     try {
98243       result = Dali::GetClosestImageSize((std::string const &)*arg1);
98244     } catch (std::out_of_range& e) {
98245       {
98246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98247       };
98248     } catch (std::exception& e) {
98249       {
98250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98251       };
98252     } catch (...) {
98253       {
98254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98255       };
98256     }
98257   }
98258   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
98259
98260   return jresult;
98261 }
98262
98263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
98264   void * jresult ;
98265   std::string *arg1 = 0 ;
98266   Dali::ImageDimensions result;
98267
98268   if (!jarg1) {
98269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98270     return 0;
98271   }
98272   std::string arg1_str(jarg1);
98273   arg1 = &arg1_str;
98274   {
98275     try {
98276       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
98277     } catch (std::out_of_range& e) {
98278       {
98279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98280       };
98281     } catch (std::exception& e) {
98282       {
98283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98284       };
98285     } catch (...) {
98286       {
98287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98288       };
98289     }
98290   }
98291   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
98292
98293   return jresult;
98294 }
98295
98296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
98297   void * jresult ;
98298   std::string *arg1 = 0 ;
98299   Dali::ImageDimensions arg2 ;
98300   Dali::FittingMode::Type arg3 ;
98301   Dali::SamplingMode::Type arg4 ;
98302   bool arg5 ;
98303   Dali::ImageDimensions *argp2 ;
98304   Dali::Devel::PixelBuffer result;
98305
98306   if (!jarg1) {
98307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98308     return 0;
98309   }
98310   std::string arg1_str(jarg1);
98311   arg1 = &arg1_str;
98312   argp2 = (Dali::ImageDimensions *)jarg2;
98313   if (!argp2) {
98314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98315     return 0;
98316   }
98317   arg2 = *argp2;
98318   arg3 = (Dali::FittingMode::Type)jarg3;
98319   arg4 = (Dali::SamplingMode::Type)jarg4;
98320   arg5 = jarg5 ? true : false;
98321   {
98322     try {
98323       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
98324     } catch (std::out_of_range& e) {
98325       {
98326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98327       };
98328     } catch (std::exception& e) {
98329       {
98330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98331       };
98332     } catch (...) {
98333       {
98334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98335       };
98336     }
98337   }
98338   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98339
98340   return jresult;
98341 }
98342
98343
98344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
98345   void * jresult ;
98346   std::string *arg1 = 0 ;
98347   Dali::ImageDimensions arg2 ;
98348   Dali::FittingMode::Type arg3 ;
98349   Dali::SamplingMode::Type arg4 ;
98350   Dali::ImageDimensions *argp2 ;
98351   Dali::Devel::PixelBuffer result;
98352
98353   if (!jarg1) {
98354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98355     return 0;
98356   }
98357   std::string arg1_str(jarg1);
98358   arg1 = &arg1_str;
98359   argp2 = (Dali::ImageDimensions *)jarg2;
98360   if (!argp2) {
98361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98362     return 0;
98363   }
98364   arg2 = *argp2;
98365   arg3 = (Dali::FittingMode::Type)jarg3;
98366   arg4 = (Dali::SamplingMode::Type)jarg4;
98367   {
98368     try {
98369       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
98370     } catch (std::out_of_range& e) {
98371       {
98372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98373       };
98374     } catch (std::exception& e) {
98375       {
98376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98377       };
98378     } catch (...) {
98379       {
98380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98381       };
98382     }
98383   }
98384   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98385
98386   return jresult;
98387 }
98388
98389
98390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
98391   void * jresult ;
98392   std::string *arg1 = 0 ;
98393   Dali::ImageDimensions arg2 ;
98394   Dali::FittingMode::Type arg3 ;
98395   Dali::ImageDimensions *argp2 ;
98396   Dali::Devel::PixelBuffer result;
98397
98398   if (!jarg1) {
98399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98400     return 0;
98401   }
98402   std::string arg1_str(jarg1);
98403   arg1 = &arg1_str;
98404   argp2 = (Dali::ImageDimensions *)jarg2;
98405   if (!argp2) {
98406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98407     return 0;
98408   }
98409   arg2 = *argp2;
98410   arg3 = (Dali::FittingMode::Type)jarg3;
98411   {
98412     try {
98413       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
98414     } catch (std::out_of_range& e) {
98415       {
98416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98417       };
98418     } catch (std::exception& e) {
98419       {
98420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98421       };
98422     } catch (...) {
98423       {
98424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98425       };
98426     }
98427   }
98428   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98429
98430   return jresult;
98431 }
98432
98433
98434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
98435   void * jresult ;
98436   std::string *arg1 = 0 ;
98437   Dali::ImageDimensions arg2 ;
98438   Dali::ImageDimensions *argp2 ;
98439   Dali::Devel::PixelBuffer result;
98440
98441   if (!jarg1) {
98442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98443     return 0;
98444   }
98445   std::string arg1_str(jarg1);
98446   arg1 = &arg1_str;
98447   argp2 = (Dali::ImageDimensions *)jarg2;
98448   if (!argp2) {
98449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98450     return 0;
98451   }
98452   arg2 = *argp2;
98453   {
98454     try {
98455       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
98456     } catch (std::out_of_range& e) {
98457       {
98458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98459       };
98460     } catch (std::exception& e) {
98461       {
98462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98463       };
98464     } catch (...) {
98465       {
98466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98467       };
98468     }
98469   }
98470   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98471
98472   return jresult;
98473 }
98474
98475
98476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
98477   void * jresult ;
98478   std::string *arg1 = 0 ;
98479   Dali::Devel::PixelBuffer result;
98480
98481   if (!jarg1) {
98482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98483     return 0;
98484   }
98485   std::string arg1_str(jarg1);
98486   arg1 = &arg1_str;
98487   {
98488     try {
98489       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
98490     } catch (std::out_of_range& e) {
98491       {
98492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98493       };
98494     } catch (std::exception& e) {
98495       {
98496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98497       };
98498     } catch (...) {
98499       {
98500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98501       };
98502     }
98503   }
98504   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98505
98506   return jresult;
98507 }
98508
98509
98510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
98511   void * jresult ;
98512   Dali::Toolkit::WebView result;
98513
98514   {
98515     try {
98516       result = Dali::Toolkit::WebView::New();
98517     } catch (std::out_of_range& e) {
98518       {
98519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98520       };
98521     } catch (std::exception& e) {
98522       {
98523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98524       };
98525     } catch (Dali::DaliException e) {
98526       {
98527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98528       };
98529     } catch (...) {
98530       {
98531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98532       };
98533     }
98534   }
98535   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98536   return jresult;
98537 }
98538
98539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
98540   void * jresult ;
98541   Dali::Toolkit::WebView result;
98542
98543   std::string *arg1;
98544   std::string *arg2;
98545
98546   if (!jarg1) {
98547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
98548     return 0;
98549   }
98550   if (!jarg2) {
98551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
98552     return 0;
98553   }
98554
98555   std::string jarg1_str = std::string(jarg1);
98556   std::string jarg2_str = std::string(jarg2);
98557
98558   arg1 = &jarg1_str;
98559   arg2 = &jarg2_str;
98560
98561   {
98562     try {
98563       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
98564     } catch (std::out_of_range& e) {
98565       {
98566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98567       };
98568     } catch (std::exception& e) {
98569       {
98570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98571       };
98572     } catch (Dali::DaliException e) {
98573       {
98574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98575       };
98576     } catch (...) {
98577       {
98578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98579       };
98580     }
98581   }
98582   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98583   return jresult;
98584 }
98585
98586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
98587   void * jresult ;
98588   Dali::Toolkit::WebView *arg1 = 0 ;
98589   Dali::Toolkit::WebView *result = 0 ;
98590
98591   arg1 = (Dali::Toolkit::WebView *)jarg1;
98592   if (!arg1) {
98593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98594     return 0;
98595   }
98596   {
98597     try {
98598       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
98599     } catch (std::out_of_range& e) {
98600       {
98601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98602       };
98603     } catch (std::exception& e) {
98604       {
98605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98606       };
98607     } catch (Dali::DaliException e) {
98608       {
98609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98610       };
98611     } catch (...) {
98612       {
98613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98614       };
98615     }
98616   }
98617   jresult = (void *)result;
98618   return jresult;
98619 }
98620
98621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
98622   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98623   arg1 = (Dali::Toolkit::WebView *)jarg1;
98624   {
98625     try {
98626       delete arg1;
98627     } catch (std::out_of_range& e) {
98628       {
98629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98630       };
98631     } catch (std::exception& e) {
98632       {
98633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98634       };
98635     } catch (Dali::DaliException e) {
98636       {
98637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98638       };
98639     } catch (...) {
98640       {
98641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98642       };
98643     }
98644   }
98645 }
98646
98647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
98648   void * jresult ;
98649   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98650   Dali::Toolkit::WebView *arg2 = 0 ;
98651   Dali::Toolkit::WebView *result = 0 ;
98652
98653   arg1 = (Dali::Toolkit::WebView *)jarg1;
98654   arg2 = (Dali::Toolkit::WebView *)jarg2;
98655   if (!arg2) {
98656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98657     return 0;
98658   }
98659   {
98660     try {
98661       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98662     } catch (std::out_of_range& e) {
98663       {
98664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98665       };
98666     } catch (std::exception& e) {
98667       {
98668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98669       };
98670     } catch (Dali::DaliException e) {
98671       {
98672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98673       };
98674     } catch (...) {
98675       {
98676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98677       };
98678     }
98679   }
98680   jresult = (void *)result;
98681   return jresult;
98682 }
98683
98684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98685   void * jresult ;
98686   Dali::BaseHandle arg1 ;
98687   Dali::BaseHandle *argp1 ;
98688   Dali::Toolkit::WebView result;
98689
98690   argp1 = (Dali::BaseHandle *)jarg1;
98691   if (!argp1) {
98692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98693     return 0;
98694   }
98695   arg1 = *argp1;
98696   {
98697     try {
98698       result = Dali::Toolkit::WebView::DownCast(arg1);
98699     } catch (std::out_of_range& e) {
98700       {
98701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98702       };
98703     } catch (std::exception& e) {
98704       {
98705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98706       };
98707     } catch (Dali::DaliException e) {
98708       {
98709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98710       };
98711     } catch (...) {
98712       {
98713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98714       };
98715     }
98716   }
98717   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98718   return jresult;
98719 }
98720
98721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98722   return (int) Dali::Toolkit::WebView::Property::URL;
98723 }
98724
98725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98726   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98727 }
98728
98729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98730   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98731 }
98732
98733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98734   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98735 }
98736
98737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98738   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98739 }
98740
98741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98742   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98743 }
98744
98745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98746   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98747 }
98748
98749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98750   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98751 }
98752
98753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98754   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98755   std::string *arg2;
98756
98757   arg1 = (Dali::Toolkit::WebView *)jarg1;
98758
98759   if (!jarg2) {
98760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98761     return;
98762   }
98763
98764   std::string jarg2str = std::string(jarg2);
98765   arg2 = &jarg2str;
98766   {
98767     try {
98768       (arg1)->LoadUrl((std::string const &)*arg2);
98769     } catch (std::out_of_range& e) {
98770       {
98771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98772       };
98773     } catch (std::exception& e) {
98774       {
98775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98776       };
98777     } catch (Dali::DaliException e) {
98778       {
98779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98780       };
98781     } catch (...) {
98782       {
98783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98784       };
98785     }
98786   }
98787 }
98788
98789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98790   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98791   std::string *arg2;
98792
98793   arg1 = (Dali::Toolkit::WebView *)jarg1;
98794   if (!jarg2) {
98795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98796     return;
98797   }
98798   std::string jarg2str = std::string(jarg2);
98799   arg2 = &jarg2str;
98800   {
98801     try {
98802       (arg1)->LoadHTMLString((std::string const &)*arg2);
98803     } catch (std::out_of_range& e) {
98804       {
98805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98806       };
98807     } catch (std::exception& e) {
98808       {
98809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98810       };
98811     } catch (Dali::DaliException e) {
98812       {
98813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98814       };
98815     } catch (...) {
98816       {
98817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98818       };
98819     }
98820   }
98821 }
98822
98823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98824   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98825
98826   arg1 = (Dali::Toolkit::WebView *)jarg1;
98827   {
98828     try {
98829       (arg1)->Reload();
98830     } catch (std::out_of_range& e) {
98831       {
98832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98833       };
98834     } catch (std::exception& e) {
98835       {
98836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98837       };
98838     } catch (Dali::DaliException e) {
98839       {
98840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98841       };
98842     } catch (...) {
98843       {
98844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98845       };
98846     }
98847   }
98848 }
98849
98850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98851   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98852
98853   arg1 = (Dali::Toolkit::WebView *)jarg1;
98854   {
98855     try {
98856       (arg1)->StopLoading();
98857     } catch (std::out_of_range& e) {
98858       {
98859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98860       };
98861     } catch (std::exception& e) {
98862       {
98863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98864       };
98865     } catch (Dali::DaliException e) {
98866       {
98867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98868       };
98869     } catch (...) {
98870       {
98871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98872       };
98873     }
98874   }
98875 }
98876
98877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98878   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98879
98880   arg1 = (Dali::Toolkit::WebView *)jarg1;
98881   {
98882     try {
98883       (arg1)->Suspend();
98884     } catch (std::out_of_range& e) {
98885       {
98886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98887       };
98888     } catch (std::exception& e) {
98889       {
98890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98891       };
98892     } catch (Dali::DaliException e) {
98893       {
98894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98895       };
98896     } catch (...) {
98897       {
98898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98899       };
98900     }
98901   }
98902 }
98903
98904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98905   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98906
98907   arg1 = (Dali::Toolkit::WebView *)jarg1;
98908   {
98909     try {
98910       (arg1)->Resume();
98911     } catch (std::out_of_range& e) {
98912       {
98913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98914       };
98915     } catch (std::exception& e) {
98916       {
98917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98918       };
98919     } catch (Dali::DaliException e) {
98920       {
98921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98922       };
98923     } catch (...) {
98924       {
98925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98926       };
98927     }
98928   }
98929 }
98930
98931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98932   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98933
98934   arg1 = (Dali::Toolkit::WebView *)jarg1;
98935   {
98936     try {
98937       (arg1)->GoBack();
98938     } catch (std::out_of_range& e) {
98939       {
98940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98941       };
98942     } catch (std::exception& e) {
98943       {
98944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98945       };
98946     } catch (Dali::DaliException e) {
98947       {
98948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98949       };
98950     } catch (...) {
98951       {
98952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98953       };
98954     }
98955   }
98956 }
98957
98958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98959   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98960
98961   arg1 = (Dali::Toolkit::WebView *)jarg1;
98962   {
98963     try {
98964       (arg1)->GoForward();
98965     } catch (std::out_of_range& e) {
98966       {
98967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98968       };
98969     } catch (std::exception& e) {
98970       {
98971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98972       };
98973     } catch (Dali::DaliException e) {
98974       {
98975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98976       };
98977     } catch (...) {
98978       {
98979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98980       };
98981     }
98982   }
98983 }
98984
98985 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98986   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98987   bool ret;
98988
98989   arg1 = (Dali::Toolkit::WebView *)jarg1;
98990   {
98991     try {
98992       ret = (arg1)->CanGoBack();
98993     } catch (std::out_of_range& e) {
98994       {
98995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98996       };
98997     } catch (std::exception& e) {
98998       {
98999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
99000       };
99001     } catch (Dali::DaliException e) {
99002       {
99003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
99004       };
99005     } catch (...) {
99006       {
99007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
99008       };
99009     }
99010   }
99011   return ret;
99012 }
99013
99014 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
99015   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99016   bool ret;
99017
99018   arg1 = (Dali::Toolkit::WebView *)jarg1;
99019   {
99020     try {
99021       ret = (arg1)->CanGoForward();
99022     } catch (std::out_of_range& e) {
99023       {
99024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
99025       };
99026     } catch (std::exception& e) {
99027       {
99028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
99029       };
99030     } catch (Dali::DaliException e) {
99031       {
99032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
99033       };
99034     } catch (...) {
99035       {
99036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
99037       };
99038     }
99039   }
99040   return ret;
99041 }
99042
99043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
99044   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99045   std::string *arg2;
99046
99047   arg1 = (Dali::Toolkit::WebView *)jarg1;
99048   if (!jarg2) {
99049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99050     return;
99051   }
99052   std::string jarg2_str = std::string(jarg2);
99053   arg2 = &jarg2_str;
99054
99055   {
99056     try {
99057       if (jarg3) {
99058         void (*handler)(char*) = (void (*)(char*)) jarg3;
99059         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
99060           handler(SWIG_csharp_string_callback(result.c_str()));
99061         });
99062       } else {
99063         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
99064       }
99065     } catch (std::out_of_range& e) {
99066       {
99067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99068       };
99069     } catch (std::exception& e) {
99070       {
99071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99072       };
99073     } catch (Dali::DaliException e) {
99074       {
99075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99076       };
99077     } catch (...) {
99078       {
99079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99080       };
99081     }
99082   }
99083 }
99084
99085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
99086 {
99087   if (!jarg2) {
99088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99089     return;
99090   }
99091
99092   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
99093   std::string exposedObjectName = jarg2;
99094   void (*handler)(char*) = (void (*)(char*)) jarg3;
99095
99096   {
99097     try {
99098       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
99099         handler(SWIG_csharp_string_callback(message.c_str()));
99100       });
99101     } catch (std::out_of_range& e) {
99102       {
99103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99104       };
99105     } catch (std::exception& e) {
99106       {
99107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99108       };
99109     } catch (Dali::DaliException e) {
99110       {
99111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99112       };
99113     } catch (...) {
99114       {
99115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99116       };
99117     }
99118   }
99119 }
99120
99121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
99122   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99123
99124   arg1 = (Dali::Toolkit::WebView *)jarg1;
99125   {
99126     try {
99127       (arg1)->ClearHistory();
99128     } catch (std::out_of_range& e) {
99129       {
99130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99131       };
99132     } catch (std::exception& e) {
99133       {
99134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99135       };
99136     } catch (Dali::DaliException e) {
99137       {
99138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99139       };
99140     } catch (...) {
99141       {
99142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99143       };
99144     }
99145   }
99146 }
99147
99148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
99149   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99150
99151   arg1 = (Dali::Toolkit::WebView *)jarg1;
99152   {
99153     try {
99154       (arg1)->ClearCache();
99155     } catch (std::out_of_range& e) {
99156       {
99157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99158       };
99159     } catch (std::exception& e) {
99160       {
99161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99162       };
99163     } catch (Dali::DaliException e) {
99164       {
99165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99166       };
99167     } catch (...) {
99168       {
99169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99170       };
99171     }
99172   }
99173 }
99174
99175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
99176   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
99177
99178   arg1 = (Dali::Toolkit::WebView *)jarg1;
99179   {
99180     try {
99181       (arg1)->ClearCookies();
99182     } catch (std::out_of_range& e) {
99183       {
99184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99185       };
99186     } catch (std::exception& e) {
99187       {
99188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99189       };
99190     } catch (Dali::DaliException e) {
99191       {
99192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99193       };
99194     } catch (...) {
99195       {
99196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99197       };
99198     }
99199   }
99200 }
99201
99202 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
99203     return (Dali::Toolkit::Control *)jarg1;
99204 }
99205
99206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
99207   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
99208   SignalConverter::WebViewPageLoadSignal* result = NULL;
99209   {
99210     try {
99211       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
99212     } catch (std::out_of_range& e) {
99213       {
99214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99215       };
99216     } catch (std::exception& e) {
99217       {
99218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99219       };
99220     } catch (Dali::DaliException e) {
99221       {
99222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99223       };
99224     } catch (...) {
99225       {
99226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99227       };
99228     }
99229   }
99230   return (void*) result;
99231 }
99232
99233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
99234   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
99235   SignalConverter::WebViewPageLoadSignal* result = NULL;
99236   {
99237     try {
99238       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
99239     } catch (std::out_of_range& e) {
99240       {
99241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99242       };
99243     } catch (std::exception& e) {
99244       {
99245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99246       };
99247     } catch (Dali::DaliException e) {
99248       {
99249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99250       };
99251     } catch (...) {
99252       {
99253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99254       };
99255     }
99256   }
99257   return (void*) result;
99258 }
99259
99260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
99261 {
99262   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
99263   {
99264     try {
99265       delete object;
99266     } catch (std::out_of_range& e) {
99267       {
99268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99269       };
99270     } catch (std::exception& e) {
99271       {
99272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99273       };
99274     } catch (Dali::DaliException e) {
99275       {
99276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99277       };
99278     } catch (...) {
99279       {
99280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99281       };
99282     }
99283   }
99284 }
99285
99286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
99287 {
99288   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
99289   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
99290   {
99291     try {
99292       proxy->Connect(callback);
99293     } catch (std::out_of_range& e) {
99294       {
99295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99296       };
99297     } catch (std::exception& e) {
99298       {
99299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99300       };
99301     } catch (Dali::DaliException e) {
99302       {
99303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99304       };
99305     } catch (...) {
99306       {
99307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99308       };
99309     }
99310   }
99311 }
99312
99313
99314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
99315   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
99316   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
99317   {
99318     try {
99319       proxy->Disconnect(callback);
99320     } catch (std::out_of_range& e) {
99321       {
99322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99323       };
99324     } catch (std::exception& e) {
99325       {
99326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99327       };
99328     } catch (Dali::DaliException e) {
99329       {
99330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99331       };
99332     } catch (...) {
99333       {
99334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99335       };
99336     }
99337   }
99338 }
99339
99340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
99341   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
99342   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
99343   {
99344     try {
99345       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
99346     } catch (std::out_of_range& e) {
99347       {
99348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99349       };
99350     } catch (std::exception& e) {
99351       {
99352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99353       };
99354     } catch (Dali::DaliException e) {
99355       {
99356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99357       };
99358     } catch (...) {
99359       {
99360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99361       };
99362     }
99363   }
99364   return (void*) result;
99365 }
99366
99367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
99368 {
99369   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99370   {
99371     try {
99372       delete object;
99373     } catch (std::out_of_range& e) {
99374       {
99375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99376       };
99377     } catch (std::exception& e) {
99378       {
99379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99380       };
99381     } catch (Dali::DaliException e) {
99382       {
99383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99384       };
99385     } catch (...) {
99386       {
99387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99388       };
99389     }
99390   }
99391 }
99392
99393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
99394 {
99395   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99396   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
99397   {
99398     try {
99399       proxy->Connect(callback);
99400     } catch (std::out_of_range& e) {
99401       {
99402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99403       };
99404     } catch (std::exception& e) {
99405       {
99406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99407       };
99408     } catch (Dali::DaliException e) {
99409       {
99410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99411       };
99412     } catch (...) {
99413       {
99414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99415       };
99416     }
99417   }
99418 }
99419
99420
99421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
99422   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99423   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
99424   {
99425     try {
99426       proxy->Disconnect(callback);
99427     } catch (std::out_of_range& e) {
99428       {
99429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99430       };
99431     } catch (std::exception& e) {
99432       {
99433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99434       };
99435     } catch (Dali::DaliException e) {
99436       {
99437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99438       };
99439     } catch (...) {
99440       {
99441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99442       };
99443     }
99444   }
99445 }
99446
99447 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
99448   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
99449   char * jresult = SWIG_csharp_string_callback((const char *)result);
99450   return jresult;
99451 }
99452
99453 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
99454   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
99455   return result;
99456 }
99457
99458
99459 struct NativeImageSourcePtrHandle
99460 {
99461   NativeImageSourcePtr Ptr;
99462 };
99463
99464 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
99465 {
99466   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99467   return (NativeImageInterface*)(arg1);
99468 }
99469
99470 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
99471 {
99472   void* jresult;
99473   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
99474   {
99475     try {
99476       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
99477     }
99478     catch (std::out_of_range & e) {
99479       {
99480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99481       };
99482     }
99483     catch (std::exception & e) {
99484       {
99485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99486       };
99487     }
99488     catch (Dali::DaliException e) {
99489       {
99490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99491       };
99492     }
99493     catch (...) {
99494       {
99495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99496       };
99497     }
99498   }
99499   jresult = (void *)handle;
99500   return jresult;
99501 }
99502
99503 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
99504 {
99505   void* jresult;
99506   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
99507   jresult = (void*)( handle->Ptr.Get() );
99508   return jresult;
99509 }
99510
99511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
99512   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
99513   {
99514     try {
99515       delete arg1;
99516     }
99517     catch (std::out_of_range & e) {
99518       {
99519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
99520       };
99521     }
99522     catch (std::exception & e) {
99523       {
99524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
99525       };
99526     }
99527     catch (Dali::DaliException e) {
99528       {
99529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
99530       };
99531     }
99532     catch (...) {
99533       {
99534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
99535       };
99536     }
99537   }
99538 }
99539
99540 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
99541 {
99542   void* jresult;
99543   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99544   uint16_t* arg2 = (uint16_t*)(jarg2);
99545   uint16_t* arg3 = (uint16_t*)(jarg3);
99546   uint16_t* arg4 = (uint16_t*)(jarg4);
99547   {
99548     try {
99549       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
99550     }
99551     catch (std::out_of_range & e) {
99552       {
99553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99554       };
99555     }
99556     catch (std::exception & e) {
99557       {
99558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99559       };
99560     }
99561     catch (Dali::DaliException e) {
99562       {
99563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99564       };
99565     }
99566     catch (...) {
99567       {
99568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99569       };
99570     }
99571   }
99572   return jresult;
99573 }
99574
99575 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
99576 {
99577   bool jresult;
99578   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99579
99580   {
99581     try {
99582       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
99583     }
99584     catch (std::out_of_range & e) {
99585       {
99586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99587       };
99588     }
99589     catch (std::exception & e) {
99590       {
99591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99592       };
99593     }
99594     catch (Dali::DaliException e) {
99595       {
99596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99597       };
99598     }
99599     catch (...) {
99600       {
99601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99602       };
99603     }
99604   }
99605   return jresult;
99606 }
99607
99608
99609 #ifdef __cplusplus
99610 }
99611 #endif
99612